map.c

早期freebsd实现

    el->el_map.vii   = NULL;
    el_free((ptr_t) el->el_map.help);
    el->el_map.help  = NULL;
    el_free((ptr_t) el->el_map.func);
    el->el_map.func  = NULL;
}


/* map_init_nls():
 *	Find all the printable keys and bind them to self insert
 */
private void
map_init_nls(el)
    EditLine *el;
{
    int i;
    el_action_t *map = el->el_map.key;

    for (i = 0200; i <= 0377; i++) 
	if (isprint(i)) 
	    map[i] = ED_INSERT;
}


/* map_init_meta():
 *	Bind all the meta keys to the appropriate ESC-<key> sequence
 */
private void
map_init_meta(el)
    EditLine *el;
{
    char    buf[3];
    register int i;
    el_action_t *map = el->el_map.key;
    el_action_t *alt = el->el_map.alt;

    for (i = 0; i <= 0377 && map[i] != EM_META_NEXT; i++)
	continue;

    if (i > 0377) {
	for (i = 0; i <= 0377 && alt[i] != EM_META_NEXT; i++)
	    continue;
	if (i > 0377) {
	    i = 033;
	    if (el->el_map.type == MAP_VI)
		map = alt;
	}
	else 
	    map = alt;
    }
    buf[0] = (char) i;
    buf[2] = 0;
    for (i = 0200; i <= 0377; i++) 
	switch (map[i]) {
	case ED_INSERT:
	case ED_UNASSIGNED:
	case ED_SEQUENCE_LEAD_IN:
	    break;
	default:
	    buf[1] = i & 0177;
	    key_add(el, buf, key_map_cmd(el, (int) map[i]), XK_CMD);
	    break;
	}
    map[buf[0]] = ED_SEQUENCE_LEAD_IN;
}


/* map_init_vi():
 *	Initialize the vi bindings
 */
protected void
map_init_vi(el)
    EditLine *el;
{
    register int i;
    el_action_t *key = el->el_map.key;
    el_action_t *alt = el->el_map.alt;
    el_action_t *vii = el->el_map.vii;
    el_action_t *vic = el->el_map.vic;

    el->el_map.type = MAP_VI;
    el->el_map.current = el->el_map.key;

    key_reset(el);

    for (i = 0; i < N_KEYS; i++) {
	key[i] = vii[i];
	alt[i] = vic[i];
    }

    map_init_meta(el);
#ifdef notyet
    if (0 /* XXX: USER has set LC_CTYPE */)
	map_init_nls(el);
#endif

    tty_bind_char(el, 1);
    term_bind_arrow(el);
}


/* map_init_emacs():
 *	Initialize the emacs bindings
 */
protected void
map_init_emacs(el)
    EditLine *el;
{
    int i;
    char    buf[3];
    el_action_t *key   = el->el_map.key;
    el_action_t *alt   = el->el_map.alt;
    el_action_t *emacs = el->el_map.emacs;

    el->el_map.type = MAP_EMACS;
    el->el_map.current = el->el_map.key;
    key_reset(el);

    for (i = 0; i < N_KEYS; i++) {
	key[i] = emacs[i];
	alt[i] = ED_UNASSIGNED;
    }

    map_init_meta(el);
#ifdef notyet
    if (0 /* XXX: USER has set LC_CTYPE */)
	map_init_nls(el);
#endif
    map_init_nls(el);

    buf[0] = CONTROL('X');
    buf[2] = 0;
    buf[1] = CONTROL('X');
    key_add(el, buf, key_map_cmd(el, EM_EXCHANGE_MARK), XK_CMD);
    
    tty_bind_char(el, 1);
    term_bind_arrow(el);
}


/* map_set_editor():
 *	Set the editor 
 */
protected int
map_set_editor(el, editor)
    EditLine *el;
    char *editor;
{
    if (strcmp(editor, "emacs") == 0) {
	map_init_emacs(el);
	return 0;
    }
    if (strcmp(editor, "vi") == 0) {
	map_init_vi(el);
	return 0;
    }
    return -1;
}


/* map_print_key():
 *	Print the function description for 1 key
 */
private void
map_print_key(el, map, in)
    EditLine *el;
    el_action_t *map;
    char *in;
{
    char outbuf[EL_BUFSIZ];
    el_bindings_t *bp;

    if (in[0] == '\0' || in[1] == '\0') {
	(void) key__decode_str(in, outbuf, "");
	for (bp = el->el_map.help; bp->name != NULL; bp++)
	    if (bp->func == map[(unsigned char) *in]) {
		(void) fprintf(el->el_outfile, 
			       "%s\t->\t%s\n", outbuf, bp->name);
		return;
	    }
    }
    else 
	key_print(el, in);
}


/* map_print_some_keys():
 *	Print keys from first to last
 */
private void
map_print_some_keys(el, map, first, last)
    EditLine *el;
    el_action_t *map;
    int     first, last;
{
    el_bindings_t *bp;
    char    firstbuf[2], lastbuf[2];
    char unparsbuf[EL_BUFSIZ], extrabuf[EL_BUFSIZ];

    firstbuf[0] = first;
    firstbuf[1] = 0;
    lastbuf[0] = last;
    lastbuf[1] = 0;
    if (map[first] == ED_UNASSIGNED) {
	if (first == last)
	    (void) fprintf(el->el_outfile, "%-15s->  is undefined\n",
		    key__decode_str(firstbuf, unparsbuf, STRQQ));
	return;
    }

    for (bp = el->el_map.help; bp->name != NULL; bp++) {
	if (bp->func == map[first]) {
	    if (first == last) {
		(void) fprintf(el->el_outfile, "%-15s->  %s\n",
			       key__decode_str(firstbuf, unparsbuf, STRQQ), 
			       bp->name);
	    }
	    else {
		(void) fprintf(el->el_outfile, "%-4s to %-7s->  %s\n",
			       key__decode_str(firstbuf, unparsbuf, STRQQ),
			       key__decode_str(lastbuf, extrabuf, STRQQ), 
			       bp->name);
	    }
	    return;
	}
    }
#ifdef MAP_DEBUG
    if (map == el->el_map.key) {
	(void) fprintf(el->el_outfile, "BUG!!! %s isn't bound to anything.\n",
		       key__decode_str(firstbuf, unparsbuf, STRQQ));
	(void) fprintf(el->el_outfile, "el->el_map.key[%d] == %d\n", 
		       first, el->el_map.key[first]);
    }
    else {
	(void) fprintf(el->el_outfile, "BUG!!! %s isn't bound to anything.\n",
		       key__decode_str(firstbuf, unparsbuf, STRQQ));
	(void) fprintf(el->el_outfile, "el->el_map.alt[%d] == %d\n", 
		       first, el->el_map.alt[first]);
    }
#endif
    abort();
}


/* map_print_all_keys():
 *	Print the function description for all keys.
 */
private void
map_print_all_keys(el)
    EditLine *el;
{
    int     prev, i;

    (void) fprintf(el->el_outfile, "Standard key bindings\n");
    prev = 0;
    for (i = 0; i < N_KEYS; i++) {
	if (el->el_map.key[prev] == el->el_map.key[i])
	    continue;
	map_print_some_keys(el, el->el_map.key, prev, i - 1);
	prev = i;
    }
    map_print_some_keys(el, el->el_map.key, prev, i - 1);

    (void) fprintf(el->el_outfile, "Alternative key bindings\n");
    prev = 0;
    for (i = 0; i < N_KEYS; i++) {
	if (el->el_map.alt[prev] == el->el_map.alt[i])
	    continue;
	map_print_some_keys(el, el->el_map.alt, prev, i - 1);
	prev = i;
    }
    map_print_some_keys(el, el->el_map.alt, prev, i - 1);

    (void) fprintf(el->el_outfile, "Multi-character bindings\n");
    key_print(el, "");
    (void) fprintf(el->el_outfile, "Arrow key bindings\n");
    term_print_arrow(el, "");
}


/* map_bind():
 *	Add/remove/change bindings
 */
protected int
map_bind(el, argc, argv)
    EditLine *el;
    int argc;
    char **argv;
{
    el_action_t *map;
    int     ntype, remove;
    char   *p;
    char    inbuf[EL_BUFSIZ];
    char    outbuf[EL_BUFSIZ];
    char   *in = NULL;
    char   *out = NULL;
    el_bindings_t *bp;
    int     cmd;
    int	    key;

    if (argv == NULL)
	return -1;

    map = el->el_map.key;
    ntype = XK_CMD;
    key = remove = 0;
    for (argc = 1; (p = argv[argc]) != NULL; argc++)
	if (p[0] == '-')
	    switch (p[1]) {
	    case 'a':
		map = el->el_map.alt;
		break;

	    case 's':
		ntype = XK_STR;
		break;
#ifdef notyet
	    case 'c':
		ntype = XK_EXE;
		break;
#endif
	    case 'k':
		key = 1;
		break;

	    case 'r':
		remove = 1;
		break;

	    case 'v':
		map_init_vi(el);
		return 0;

	    case 'e':
		map_init_emacs(el);
		return 0;

	    case 'l':
		for (bp = el->el_map.help; bp->name != NULL; bp++) 
		    (void) fprintf(el->el_outfile, "%s\n\t%s\n", 
				   bp->name, bp->description);
		return 0;
	    default:
		(void) fprintf(el->el_errfile, "%s: Invalid switch `%c'.\n",
			       argv[0], p[1]);
	    }
	else
	    break;

    if (argv[argc] == NULL) {
	map_print_all_keys(el);
	return 0;
    }

    if (key)
	in = argv[argc++];
    else
	if ((in = parse__string(inbuf, argv[argc++])) == NULL) {
	    (void) fprintf(el->el_errfile, "%s: Invalid \\ or ^ in instring.\n",
			   argv[0]);
	    return -1;
	}

    if (remove) {
	if (key) {
	    (void) term_clear_arrow(el, in);
	    return -1;
	}
	if (in[1]) 
	    (void) key_delete(el, in);
	else if (map[(unsigned char) *in] == ED_SEQUENCE_LEAD_IN) 
	    (void) key_delete(el, in);
	else 
	    map[(unsigned char) *in] = ED_UNASSIGNED;
	return 0;
    }

    if (argv[argc] == NULL) {
	if (key)
	    term_print_arrow(el, in);
	else
	    map_print_key(el, map, in);
	return 0;
    }

#ifdef notyet
    if (argv[argc + 1] != NULL) {
	bindkey_usage();
	return -1;
    }
#endif

    switch (ntype) {
    case XK_STR:
    case XK_EXE:
	if ((out = parse__string(outbuf, argv[argc])) == NULL) {
	    (void) fprintf(el->el_errfile, 
			   "%s: Invalid \\ or ^ in outstring.\n", argv[0]);
	    return -1;
	}
	if (key)
	    term_set_arrow(el, in, key_map_str(el, out), ntype);
	else
	    key_add(el, in, key_map_str(el, out), ntype);
	map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
	break;

    case XK_CMD:
	if ((cmd = parse_cmd(el, argv[argc])) == -1) {
	    (void) fprintf(el->el_errfile, 
			   "%s: Invalid command `%s'.\n", argv[0], argv[argc]);
	    return -1;
	}
	if (key)
	    term_set_arrow(el, in, key_map_str(el, out), ntype);
	else {
	    if (in[1]) {
		key_add(el, in, key_map_cmd(el, cmd), ntype);
		map[(unsigned char) *in] = ED_SEQUENCE_LEAD_IN;
	    }
	    else  {
		key_clear(el, map, in);
		map[(unsigned char) *in] = cmd;
	    }
	}
	break;

    default:
	abort();
	break;
    }
    return 0;
}


/* map_addfunc():
 *	add a user defined function
 */
protected int
map_addfunc(el, name, help, func)
    EditLine *el;
    const char *name;
    const char *help;
    el_func_t func;
{
    int nf = el->el_map.nfunc + 2;
    if (name == NULL || help == NULL || func == NULL)
	return -1;

    el->el_map.func = (el_func_t *) 
		el_realloc(el->el_map.func, nf * sizeof(el_func_t));
    el->el_map.help = (el_bindings_t *)
		el_realloc(el->el_map.help, nf * sizeof(el_bindings_t));

    nf = el->el_map.nfunc;
    el->el_map.func[nf] = func;

    el->el_map.help[nf].name = name;
    el->el_map.help[nf].func = nf;
    el->el_map.help[nf].description = help;
    el->el_map.help[++nf].name = NULL;
    el->el_map.nfunc++;

    return 0;
}