X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fkeymap.c;h=046c5e836d57e98d2713ebdfa65f45fb9bb16272;hb=2bf45e07013c281a55bc509b24f5e83568f3d0fd;hp=efab47db1bd9c647c2187cef2858c507c342bb41;hpb=6883ee56ec887c2c48abe5b06b5e66aa74031910;p=chise%2Fxemacs-chise.git.1 diff --git a/src/keymap.c b/src/keymap.c index efab47d..046c5e8 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -30,7 +30,6 @@ Boston, MA 02111-1307, USA. */ #include "buffer.h" #include "bytecode.h" -#include "commands.h" #include "console.h" #include "elhash.h" #include "events.h" @@ -142,7 +141,7 @@ Boston, MA 02111-1307, USA. */ Since keymaps are opaque, the only way to extract information from them is with the functions lookup-key, key-binding, local-key-binding, and global-key-binding, which work just as before, and the new function - map-keymap, which is roughly analagous to maphash. + map-keymap, which is roughly analogous to maphash. Note that map-keymap perpetuates the illusion that the "bucky" submaps don't exist: if you map over a keymap with bucky submaps, it will also @@ -157,39 +156,26 @@ Boston, MA 02111-1307, USA. */ */ -struct keymap +struct Lisp_Keymap { struct lcrecord_header header; - Lisp_Object parents; /* Keymaps to be searched after this one - * An ordered list */ + Lisp_Object parents; /* Keymaps to be searched after this one. + An ordered list */ Lisp_Object prompt; /* Qnil or a string to print in the minibuffer - * when reading from this keymap */ - + when reading from this keymap */ Lisp_Object table; /* The contents of this keymap */ Lisp_Object inverse_table; /* The inverse mapping of the above */ - Lisp_Object default_binding; /* Use this if no other binding is found - * (this overrides parent maps and the - * normal global-map lookup). */ - - + (this overrides parent maps and the + normal global-map lookup). */ Lisp_Object sub_maps_cache; /* Cache of directly inferior keymaps; This holds an alist, of the key and the maps, or the modifier bit and the map. If this is the symbol t, then the cache - needs to be recomputed. - */ - int fullness; /* How many entries there are in this table. - This should be the same as the fullness - of the `table', but hash.c is broken. */ + needs to be recomputed. */ Lisp_Object name; /* Just for debugging convenience */ }; -#define XKEYMAP(x) XRECORD (x, keymap, struct keymap) -#define XSETKEYMAP(x, p) XSETRECORD (x, p, keymap) -#define KEYMAPP(x) RECORDP (x, keymap) -#define CHECK_KEYMAP(x) CHECK_RECORD (x, keymap) - #define MAKE_MODIFIER_HASH_KEY(modifier) make_int (modifier) #define MODIFIER_HASH_KEY_BITS(x) (INTP (x) ? XINT (x) : 0) @@ -197,7 +183,7 @@ struct keymap /* Actually allocate storage for these variables */ -static Lisp_Object Vcurrent_global_map; /* Always a keymap */ +Lisp_Object Vcurrent_global_map; /* Always a keymap */ static Lisp_Object Vmouse_grabbed_buffer; @@ -236,6 +222,7 @@ static void describe_map (Lisp_Object keymap, Lisp_Object elt_prefix, Lisp_Object shadow, int mice_only_p, Lisp_Object buffer); +static Lisp_Object keymap_submaps (Lisp_Object keymap); Lisp_Object Qcontrol, Qctrl, Qmeta, Qsuper, Qhyper, Qalt, Qshift; Lisp_Object Qbutton0, Qbutton1, Qbutton2, Qbutton3; @@ -258,15 +245,15 @@ Lisp_Object QLFD, QTAB, QRET, QESC, QDEL, QSPC, QBS; /************************************************************************/ static Lisp_Object -mark_keymap (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_keymap (Lisp_Object obj) { - struct keymap *keymap = XKEYMAP (obj); - ((markobj) (keymap->parents)); - ((markobj) (keymap->prompt)); - ((markobj) (keymap->inverse_table)); - ((markobj) (keymap->sub_maps_cache)); - ((markobj) (keymap->default_binding)); - ((markobj) (keymap->name)); + Lisp_Keymap *keymap = XKEYMAP (obj); + mark_object (keymap->parents); + mark_object (keymap->prompt); + mark_object (keymap->inverse_table); + mark_object (keymap->sub_maps_cache); + mark_object (keymap->default_binding); + mark_object (keymap->name); return keymap->table; } @@ -274,27 +261,37 @@ static void print_keymap (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { /* This function can GC */ - struct keymap *keymap = XKEYMAP (obj); + Lisp_Keymap *keymap = XKEYMAP (obj); char buf[200]; - int size = XINT (Fkeymap_fullness (obj)); if (print_readably) error ("printing unreadable object #", keymap->header.uid); write_c_string ("#name)) - print_internal (keymap->name, printcharfun, 1); - /* #### Yuck! This is no way to form plural! --hniksic */ - sprintf (buf, "%s%d entr%s 0x%x>", - ((NILP (keymap->name)) ? "" : " "), - size, - ((size == 1) ? "y" : "ies"), - keymap->header.uid); + { + print_internal (keymap->name, printcharfun, 1); + write_c_string (" ", printcharfun); + } + sprintf (buf, "size %ld 0x%x>", + (long) XINT (Fkeymap_fullness (obj)), keymap->header.uid); write_c_string (buf, printcharfun); } +static const struct lrecord_description keymap_description[] = { + { XD_LISP_OBJECT, offsetof (Lisp_Keymap, parents) }, + { XD_LISP_OBJECT, offsetof (Lisp_Keymap, prompt) }, + { XD_LISP_OBJECT, offsetof (Lisp_Keymap, table) }, + { XD_LISP_OBJECT, offsetof (Lisp_Keymap, inverse_table) }, + { XD_LISP_OBJECT, offsetof (Lisp_Keymap, default_binding) }, + { XD_LISP_OBJECT, offsetof (Lisp_Keymap, sub_maps_cache) }, + { XD_LISP_OBJECT, offsetof (Lisp_Keymap, name) }, + { XD_END } +}; + /* No need for keymap_equal #### Why not? */ DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap, mark_keymap, print_keymap, 0, 0, 0, - struct keymap); + keymap_description, + Lisp_Keymap); /************************************************************************/ /* Traversing keymaps and their parents */ @@ -318,19 +315,19 @@ traverse_keymaps (Lisp_Object start_keymap, Lisp_Object start_parents, start_keymap = get_keymap (start_keymap, 1, 1); keymap = start_keymap; /* Hack special-case parents at top-level */ - tail = ((!NILP (tail)) ? tail : XKEYMAP (keymap)->parents); + tail = !NILP (tail) ? tail : XKEYMAP (keymap)->parents; for (;;) { Lisp_Object result; QUIT; - result = ((mapper) (keymap, mapper_arg)); + result = mapper (keymap, mapper_arg); if (!NILP (result)) { while (CONSP (malloc_bites)) { - struct Lisp_Cons *victim = XCONS (malloc_bites); + Lisp_Cons *victim = XCONS (malloc_bites); malloc_bites = victim->cdr; free_cons (victim); } @@ -347,7 +344,7 @@ traverse_keymaps (Lisp_Object start_keymap, Lisp_Object start_parents, stack_depth--; if (CONSP (malloc_bites)) { - struct Lisp_Cons *victim = XCONS (malloc_bites); + Lisp_Cons *victim = XCONS (malloc_bites); tail = victim->car; malloc_bites = victim->cdr; free_cons (victim); @@ -439,7 +436,7 @@ control_meta_superify (Lisp_Object frob, unsigned int modifiers) } static Lisp_Object -make_key_description (CONST struct key_data *key, int prettify) +make_key_description (const struct key_data *key, int prettify) { Lisp_Object keysym = key->keysym; unsigned int modifiers = key->modifiers; @@ -467,7 +464,7 @@ make_key_description (CONST struct key_data *key, int prettify) static Lisp_Object raw_lookup_key (Lisp_Object keymap, - CONST struct key_data *raw_keys, int raw_keys_count, + const struct key_data *raw_keys, int raw_keys_count, int keys_so_far, int accept_default); /* Relies on caller to gc-protect args */ @@ -475,7 +472,7 @@ static Lisp_Object keymap_lookup_directly (Lisp_Object keymap, Lisp_Object keysym, unsigned int modifiers) { - struct keymap *k; + Lisp_Keymap *k; if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER | MOD_ALT | MOD_SHIFT)) != 0) @@ -534,7 +531,7 @@ keymap_store_inverse_internal (Lisp_Object inverse_table, } else { - while (CONSP (Fcdr (keys))) + while (CONSP (XCDR (keys))) keys = XCDR (keys); XCDR (keys) = Fcons (XCDR (keys), keysym); /* No need to call puthash because we've destructively @@ -582,38 +579,57 @@ keymap_delete_inverse_internal (Lisp_Object inverse_table, */ } +/* Prevent luser from shooting herself in the foot using something like + (define-key ctl-x-4-map "p" global-map) */ +static void +check_keymap_definition_loop (Lisp_Object def, Lisp_Keymap *to_keymap) +{ + def = get_keymap (def, 0, 0); + + if (KEYMAPP (def)) + { + Lisp_Object maps; + + if (XKEYMAP (def) == to_keymap) + signal_simple_error ("Cyclic keymap definition", def); + + for (maps = keymap_submaps (def); + CONSP (maps); + maps = XCDR (maps)) + check_keymap_definition_loop (XCDR (XCAR (maps)), to_keymap); + } +} static void -keymap_store_internal (Lisp_Object keysym, struct keymap *keymap, - Lisp_Object value) +keymap_store_internal (Lisp_Object keysym, Lisp_Keymap *keymap, + Lisp_Object def) { - Lisp_Object prev_value = Fgethash (keysym, keymap->table, Qnil); + Lisp_Object prev_def = Fgethash (keysym, keymap->table, Qnil); - if (EQ (prev_value, value)) + if (EQ (prev_def, def)) return; - if (!NILP (prev_value)) + + check_keymap_definition_loop (def, keymap); + + if (!NILP (prev_def)) keymap_delete_inverse_internal (keymap->inverse_table, - keysym, prev_value); - if (NILP (value)) + keysym, prev_def); + if (NILP (def)) { - keymap->fullness--; - if (keymap->fullness < 0) abort (); Fremhash (keysym, keymap->table); } else { - if (NILP (prev_value)) - keymap->fullness++; - Fputhash (keysym, value, keymap->table); + Fputhash (keysym, def, keymap->table); keymap_store_inverse_internal (keymap->inverse_table, - keysym, value); + keysym, def); } keymap_tick++; } static Lisp_Object -create_bucky_submap (struct keymap *k, unsigned int modifiers, +create_bucky_submap (Lisp_Keymap *k, unsigned int modifiers, Lisp_Object parent_for_debugging_info) { Lisp_Object submap = Fmake_sparse_keymap (Qnil); @@ -629,26 +645,19 @@ create_bucky_submap (struct keymap *k, unsigned int modifiers, /* Relies on caller to gc-protect keymap, keysym, value */ static void -keymap_store (Lisp_Object keymap, CONST struct key_data *key, +keymap_store (Lisp_Object keymap, const struct key_data *key, Lisp_Object value) { Lisp_Object keysym = key->keysym; unsigned int modifiers = key->modifiers; - struct keymap *k; - - if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER - | MOD_ALT | MOD_SHIFT)) != 0) - abort (); + Lisp_Keymap *k = XKEYMAP (keymap); - k = XKEYMAP (keymap); + assert ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER + | MOD_ALT | MOD_SHIFT)) == 0); /* If the keysym is a one-character symbol, use the char code instead. */ if (SYMBOLP (keysym) && string_char_length (XSYMBOL (keysym)->name) == 1) - { - Lisp_Object run_the_gcc_developers_over_with_a_steamroller = - make_char (string_char (XSYMBOL (keysym)->name, 0)); - keysym = run_the_gcc_developers_over_with_a_steamroller; - } + keysym = make_char (string_char (XSYMBOL (keysym)->name, 0)); if (modifiers & MOD_META) /* Utterly hateful ESC lossage */ { @@ -683,32 +692,27 @@ struct keymap_submaps_closure }; static int -keymap_submaps_mapper_0 (CONST void *hash_key, void *hash_contents, +keymap_submaps_mapper_0 (Lisp_Object key, Lisp_Object value, void *keymap_submaps_closure) { /* This function can GC */ - Lisp_Object contents; - VOID_TO_LISP (contents, hash_contents); /* Perform any autoloads, etc */ - Fkeymapp (contents); + Fkeymapp (value); return 0; } static int -keymap_submaps_mapper (CONST void *hash_key, void *hash_contents, +keymap_submaps_mapper (Lisp_Object key, Lisp_Object value, void *keymap_submaps_closure) { /* This function can GC */ - Lisp_Object key, contents; Lisp_Object *result_locative; struct keymap_submaps_closure *cl = (struct keymap_submaps_closure *) keymap_submaps_closure; - CVOID_TO_LISP (key, hash_key); - VOID_TO_LISP (contents, hash_contents); result_locative = cl->result_locative; - if (!NILP (Fkeymapp (contents))) - *result_locative = Fcons (Fcons (key, contents), *result_locative); + if (!NILP (Fkeymapp (value))) + *result_locative = Fcons (Fcons (key, value), *result_locative); return 0; } @@ -719,7 +723,7 @@ static Lisp_Object keymap_submaps (Lisp_Object keymap) { /* This function can GC */ - struct keymap *k = XKEYMAP (keymap); + Lisp_Keymap *k = XKEYMAP (keymap); if (EQ (k->sub_maps_cache, Qt)) /* Unknown */ { @@ -750,28 +754,30 @@ keymap_submaps (Lisp_Object keymap) /************************************************************************/ static Lisp_Object -make_keymap (int size) +make_keymap (size_t size) { Lisp_Object result; - struct keymap *keymap = alloc_lcrecord_type (struct keymap, lrecord_keymap); + Lisp_Keymap *keymap = alloc_lcrecord_type (Lisp_Keymap, &lrecord_keymap); XSETKEYMAP (result, keymap); - keymap->parents = Qnil; - keymap->table = Qnil; - keymap->prompt = Qnil; + keymap->parents = Qnil; + keymap->prompt = Qnil; + keymap->table = Qnil; + keymap->inverse_table = Qnil; keymap->default_binding = Qnil; - keymap->inverse_table = Qnil; - keymap->sub_maps_cache = Qnil; /* No possible submaps */ - keymap->fullness = 0; + keymap->sub_maps_cache = Qnil; /* No possible submaps */ + keymap->name = Qnil; + if (size != 0) /* hack for copy-keymap */ { - keymap->table = Fmake_hashtable (make_int (size), Qnil); + keymap->table = + make_lisp_hash_table (size, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); /* Inverse table is often less dense because of duplicate key-bindings. If not, it will grow anyway. */ - keymap->inverse_table = Fmake_hashtable (make_int (size * 3 / 4), Qnil); + keymap->inverse_table = + make_lisp_hash_table (size * 3 / 4, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); } - keymap->name = Qnil; return result; } @@ -1052,7 +1058,7 @@ get_keyelt (Lisp_Object object, int accept_default) struct key_data indirection; if (CHARP (idx)) { - struct Lisp_Event event; + Lisp_Event event; event.event_type = empty_event; character_to_event (XCHAR (idx), &event, XCONSOLE (Vselected_console), 0, 0); @@ -1063,7 +1069,7 @@ get_keyelt (Lisp_Object object, int accept_default) if (!INTP (XCDR (idx))) return Qnil; indirection.keysym = XCAR (idx); - indirection.modifiers = XINT (XCDR (idx)); + indirection.modifiers = (unsigned char) XINT (XCDR (idx)); } else if (SYMBOLP (idx)) { @@ -1094,7 +1100,7 @@ get_keyelt (Lisp_Object object, int accept_default) } static Lisp_Object -keymap_lookup_1 (Lisp_Object keymap, CONST struct key_data *key, +keymap_lookup_1 (Lisp_Object keymap, const struct key_data *key, int accept_default) { /* This function can GC */ @@ -1114,38 +1120,34 @@ struct copy_keymap_inverse_closure }; static int -copy_keymap_inverse_mapper (CONST void *hash_key, void *hash_contents, +copy_keymap_inverse_mapper (Lisp_Object key, Lisp_Object value, void *copy_keymap_inverse_closure) { - Lisp_Object key, inverse_table, inverse_contents; struct copy_keymap_inverse_closure *closure = (struct copy_keymap_inverse_closure *) copy_keymap_inverse_closure; - VOID_TO_LISP (inverse_table, closure); - VOID_TO_LISP (inverse_contents, hash_contents); - CVOID_TO_LISP (key, hash_key); /* copy-sequence deals with dotted lists. */ - if (CONSP (inverse_contents)) - inverse_contents = Fcopy_sequence (inverse_contents); - Fputhash (key, inverse_contents, closure->inverse_table); + if (CONSP (value)) + value = Fcopy_list (value); + Fputhash (key, value, closure->inverse_table); return 0; } static Lisp_Object -copy_keymap_internal (struct keymap *keymap) +copy_keymap_internal (Lisp_Keymap *keymap) { Lisp_Object nkm = make_keymap (0); - struct keymap *new_keymap = XKEYMAP (nkm); + Lisp_Keymap *new_keymap = XKEYMAP (nkm); struct copy_keymap_inverse_closure copy_keymap_inverse_closure; copy_keymap_inverse_closure.inverse_table = keymap->inverse_table; - new_keymap->parents = Fcopy_sequence (keymap->parents); - new_keymap->fullness = keymap->fullness; + new_keymap->parents = Fcopy_sequence (keymap->parents); new_keymap->sub_maps_cache = Qnil; /* No submaps */ - new_keymap->table = Fcopy_hashtable (keymap->table); - new_keymap->inverse_table = Fcopy_hashtable (keymap->inverse_table); + new_keymap->table = Fcopy_hash_table (keymap->table); + new_keymap->inverse_table = Fcopy_hash_table (keymap->inverse_table); + new_keymap->default_binding = keymap->default_binding; /* After copying the inverse map, we need to copy the conses which are its values, lest they be shared by the copy, and mangled. */ @@ -1159,30 +1161,26 @@ static Lisp_Object copy_keymap (Lisp_Object keymap); struct copy_keymap_closure { - struct keymap *self; + Lisp_Keymap *self; }; static int -copy_keymap_mapper (CONST void *hash_key, void *hash_contents, +copy_keymap_mapper (Lisp_Object key, Lisp_Object value, void *copy_keymap_closure) { /* This function can GC */ - Lisp_Object key, contents; struct copy_keymap_closure *closure = (struct copy_keymap_closure *) copy_keymap_closure; - CVOID_TO_LISP (key, hash_key); - VOID_TO_LISP (contents, hash_contents); /* When we encounter a keymap which is indirected through a symbol, we need to copy the sub-map. In v18, the form (lookup-key (copy-keymap global-map) "\C-x") returned a new keymap, not the symbol 'Control-X-prefix. */ - contents = get_keymap (contents, - 0, 1); /* #### autoload GC-safe here? */ - if (KEYMAPP (contents)) + value = get_keymap (value, 0, 1); /* #### autoload GC-safe here? */ + if (KEYMAPP (value)) keymap_store_internal (key, closure->self, - copy_keymap (contents)); + copy_keymap (value)); return 0; } @@ -1223,16 +1221,17 @@ keymap_fullness (Lisp_Object keymap) struct gcpro gcpro1, gcpro2; keymap = get_keymap (keymap, 1, 1); - fullness = XKEYMAP (keymap)->fullness; - sub_maps = keymap_submaps (keymap); + fullness = XINT (Fhash_table_count (XKEYMAP (keymap)->table)); GCPRO2 (keymap, sub_maps); - for (; !NILP (sub_maps); sub_maps = XCDR (sub_maps)) + for (sub_maps = keymap_submaps (keymap); + !NILP (sub_maps); + sub_maps = XCDR (sub_maps)) { if (MODIFIER_HASH_KEY_BITS (XCAR (XCAR (sub_maps))) != 0) { - Lisp_Object sub_map = XCDR (XCAR (sub_maps)); - fullness--; /* don't count bucky maps */ - fullness += keymap_fullness (sub_map); + Lisp_Object bucky_map = XCDR (XCAR (sub_maps)); + fullness--; /* don't count bucky maps themselves. */ + fullness += keymap_fullness (bucky_map); } } UNGCPRO; @@ -1284,19 +1283,17 @@ define_key_check_and_coerce_keysym (Lisp_Object spec, /* #### This bites! I want to be able to write (control shift a) */ if (modifiers & MOD_SHIFT) signal_simple_error - ("the `shift' modifier may not be applied to ASCII keysyms", + ("The `shift' modifier may not be applied to ASCII keysyms", spec); } else { - signal_simple_error ("unknown keysym specifier", - *keysym); + signal_simple_error ("Unknown keysym specifier", *keysym); } if (SYMBOLP (*keysym)) { - char *name = (char *) - string_data (XSYMBOL (*keysym)->name); + char *name = (char *) string_data (XSYMBOL (*keysym)->name); /* FSFmacs uses symbols with the printed representation of keysyms in their names, like 'M-x, and we use the syntax '(meta x). So, to avoid @@ -1359,6 +1356,8 @@ define_key_check_and_coerce_keysym (Lisp_Object spec, *keysym = QKescape; else if (EQ (*keysym, QDEL)) *keysym = QKdelete; + else if (EQ (*keysym, QSPC)) + *keysym = QKspace; else if (EQ (*keysym, QBS)) *keysym = QKbackspace; /* Emacs compatibility */ @@ -1398,7 +1397,7 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value) { if (CHAR_OR_CHAR_INTP (spec)) { - struct Lisp_Event event; + Lisp_Event event; event.event_type = empty_event; character_to_event (XCHAR_OR_CHAR_INT (spec), &event, XCONSOLE (Vselected_console), 0, 0); @@ -1474,19 +1473,19 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value) if (!NILP (XCDR (rest))) { if (! modifier) - signal_simple_error ("unknown modifier", keysym); + signal_simple_error ("Unknown modifier", keysym); } else { if (modifier) - signal_simple_error ("nothing but modifiers here", + signal_simple_error ("Nothing but modifiers here", spec); } rest = XCDR (rest); QUIT; } if (!NILP (rest)) - signal_simple_error ("dotted list", spec); + signal_simple_error ("List must be nil-terminated", spec); define_key_check_and_coerce_keysym (spec, &keysym, modifiers); returned_value->keysym = keysym; @@ -1494,7 +1493,7 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value) } else { - signal_simple_error ("unknown key-sequence specifier", + signal_simple_error ("Unknown key-sequence specifier", spec); } } @@ -1513,7 +1512,7 @@ key_desc_list_to_event (Lisp_Object list, Lisp_Object event, { Lisp_Object fn, arg; if (! NILP (Fcdr (Fcdr (list)))) - signal_simple_error ("invalid menu event desc", list); + signal_simple_error ("Invalid menu event desc", list); arg = Fcar (Fcdr (list)); if (SYMBOLP (arg)) fn = Qcall_interactively; @@ -1546,8 +1545,7 @@ key_desc_list_to_event (Lisp_Object list, Lisp_Object event, int -event_matches_key_specifier_p (struct Lisp_Event *event, - Lisp_Object key_specifier) +event_matches_key_specifier_p (Lisp_Event *event, Lisp_Object key_specifier) { Lisp_Object event2; int retval; @@ -1598,9 +1596,9 @@ event_matches_key_specifier_p (struct Lisp_Event *event, } static int -meta_prefix_char_p (CONST struct key_data *key) +meta_prefix_char_p (const struct key_data *key) { - struct Lisp_Event event; + Lisp_Event event; event.event_type = key_press_event; event.channel = Vselected_console; @@ -1621,6 +1619,12 @@ This can be useful, e.g., to determine if the user pressed `help-char' or ? Qt : Qnil); } +#define MACROLET(k,m) do { \ + returned_value->keysym = (k); \ + returned_value->modifiers = (m); \ + RETURN_SANS_WARNINGS; \ +} while (0) + /* ASCII grunge. Given a keysym, return another keysym/modifier pair which could be considered the same key in an ASCII world. Backspace returns ^H, for @@ -1636,9 +1640,6 @@ define_key_alternate_name (struct key_data *key, unsigned int modifiers_sans_meta = (modifiers & (~MOD_META)); returned_value->keysym = Qnil; /* By default, no "alternate" key */ returned_value->modifiers = 0; -#define MACROLET(k,m) do { returned_value->keysym = (k); \ - returned_value->modifiers = (m); \ - RETURN__; } while (0) if (modifiers_sans_meta == MOD_CONTROL) { if EQ (keysym, QKspace) @@ -1903,20 +1904,17 @@ these features. (defvar my-escape-map (lookup-key my-map "\e")) if the luser really wants the map in a variable. */ - Lisp_Object mmap; + Lisp_Object meta_map; struct gcpro ngcpro1; NGCPRO1 (c); - mmap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META), - XKEYMAP (keymap)->table, Qnil); - if (!NILP (mmap) - && keymap_fullness (mmap) != 0) - { - Lisp_Object desc - = Fsingle_key_description (Vmeta_prefix_char); - signal_simple_error_2 - ("Map contains meta-bindings, can't bind", desc, keymap); - } + meta_map = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META), + XKEYMAP (keymap)->table, Qnil); + if (!NILP (meta_map) + && keymap_fullness (meta_map) != 0) + signal_simple_error_2 + ("Map contains meta-bindings, can't bind", + Fsingle_key_description (Vmeta_prefix_char), keymap); NUNGCPRO; } else @@ -1937,7 +1935,7 @@ these features. if (metized) { - raw_key1.modifiers |= MOD_META; + raw_key1.modifiers |= MOD_META; raw_key2.modifiers |= MOD_META; metized = 0; } @@ -1970,7 +1968,7 @@ these features. keymap_store (keymap, &raw_key1, cmd); } if (NILP (Fkeymapp (cmd))) - signal_simple_error_2 ("invalid prefix keys in sequence", + signal_simple_error_2 ("Invalid prefix keys in sequence", c, keys); if (ascii_hack && !NILP (raw_key2.keysym) && @@ -1994,7 +1992,7 @@ these features. struct raw_lookup_key_mapper_closure { int remaining; - CONST struct key_data *raw_keys; + const struct key_data *raw_keys; int raw_keys_count; int keys_so_far; int accept_default; @@ -2005,7 +2003,7 @@ static Lisp_Object raw_lookup_key_mapper (Lisp_Object k, void *); /* Caller should gc-protect args (keymaps may autoload) */ static Lisp_Object raw_lookup_key (Lisp_Object keymap, - CONST struct key_data *raw_keys, int raw_keys_count, + const struct key_data *raw_keys, int raw_keys_count, int keys_so_far, int accept_default) { /* This function can GC */ @@ -2028,7 +2026,7 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg) int accept_default = c->accept_default; int remaining = c->remaining; int keys_so_far = c->keys_so_far; - CONST struct key_data *raw_keys = c->raw_keys; + const struct key_data *raw_keys = c->raw_keys; Lisp_Object cmd; if (! meta_prefix_char_p (&(raw_keys[0]))) @@ -2057,7 +2055,7 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg) * element is the meta-prefix-char will return the keymap that * the "meta" keys are stored in, if there is no binding for * the meta-prefix-char (and if this map has a "meta" submap). - * If this map doesnt have a "meta" submap, then the + * If this map doesn't have a "meta" submap, then the * meta-prefix-char is looked up just like any other key. */ if (remaining == 0) @@ -2119,7 +2117,7 @@ lookup_keys (Lisp_Object keymap, int nkeys, Lisp_Object *keys, if (nkeys == 0) return Qnil; - if (nkeys < (countof (kkk))) + if (nkeys < countof (kkk)) raw_keys = kkk; else raw_keys = alloca_array (struct key_data, nkeys); @@ -2149,7 +2147,7 @@ lookup_events (Lisp_Object event_head, int nmaps, Lisp_Object keymaps[], nkeys = event_chain_count (event_head); - if (nkeys < (countof (kkk))) + if (nkeys < countof (kkk)) raw_keys = kkk; else raw_keys = alloca_array (struct key_data, nkeys); @@ -2226,7 +2224,7 @@ it takes to reach a non-prefix command. map of the buffer in which the mouse was clicked in event0 is a click. It would be kind of nice if this were in Lisp so that this semi-hairy - semi-heuristic command-lookup behaviour could be readily understood and + semi-heuristic command-lookup behavior could be readily understood and customised. However, this needs to be pretty fast, or performance of keyboard macros goes to shit; putting this in lisp slows macros down 2-3x. And they're already slower than v18 by 5-6x. @@ -2375,8 +2373,7 @@ get_relevant_keymaps (Lisp_Object keys, get_relevant_extent_keymaps (Fevent_modeline_position (terminal), XBUFFER (buffer)->generated_modeline_string, - /* #### third arg should maybe be a glyph. */ - Qnil, &closure); + Fevent_glyph_extent (terminal), &closure); if (!UNBOUNDP (map) && !NILP (map)) relevant_map_push (get_keymap (map, 1, 1), &closure); @@ -2410,7 +2407,7 @@ get_relevant_keymaps (Lisp_Object keys, { int nmaps = closure.nmaps; - /* Silently truncate at 100 keymaps to prevent infinite losssage */ + /* Silently truncate at 100 keymaps to prevent infinite lossage */ if (nmaps >= max_maps && max_maps > 0) maps[max_maps - 1] = Vcurrent_global_map; else @@ -2426,7 +2423,7 @@ get_relevant_keymaps (Lisp_Object keys, first element in the list returned. This is so we can correctly search the keymaps associated with glyphs which may be physically disjoint from their extents: for example, if a glyph is out in the - margin, we should still consult the kemyap of that glyph's extent, + margin, we should still consult the keymap of that glyph's extent, which may not itself be under the mouse. */ @@ -2744,33 +2741,29 @@ Return the current global keymap. struct map_keymap_unsorted_closure { - void (*fn) (CONST struct key_data *, Lisp_Object binding, void *arg); + void (*fn) (const struct key_data *, Lisp_Object binding, void *arg); void *arg; unsigned int modifiers; }; /* used by map_keymap() */ static int -map_keymap_unsorted_mapper (CONST void *hash_key, void *hash_contents, +map_keymap_unsorted_mapper (Lisp_Object keysym, Lisp_Object value, void *map_keymap_unsorted_closure) { /* This function can GC */ - Lisp_Object keysym; - Lisp_Object contents; struct map_keymap_unsorted_closure *closure = (struct map_keymap_unsorted_closure *) map_keymap_unsorted_closure; unsigned int modifiers = closure->modifiers; unsigned int mod_bit; - CVOID_TO_LISP (keysym, hash_key); - VOID_TO_LISP (contents, hash_contents); mod_bit = MODIFIER_HASH_KEY_BITS (keysym); if (mod_bit != 0) { int omod = modifiers; closure->modifiers = (modifiers | mod_bit); - contents = get_keymap (contents, 1, 0); + value = get_keymap (value, 1, 0); elisp_maphash (map_keymap_unsorted_mapper, - XKEYMAP (contents)->table, + XKEYMAP (value)->table, map_keymap_unsorted_closure); closure->modifiers = omod; } @@ -2779,7 +2772,7 @@ map_keymap_unsorted_mapper (CONST void *hash_key, void *hash_contents, struct key_data key; key.keysym = keysym; key.modifiers = modifiers; - ((*closure->fn) (&key, contents, closure->arg)); + ((*closure->fn) (&key, value, closure->arg)); } return 0; } @@ -2792,16 +2785,13 @@ struct map_keymap_sorted_closure /* used by map_keymap_sorted() */ static int -map_keymap_sorted_mapper (CONST void *hash_key, void *hash_contents, +map_keymap_sorted_mapper (Lisp_Object key, Lisp_Object value, void *map_keymap_sorted_closure) { struct map_keymap_sorted_closure *cl = (struct map_keymap_sorted_closure *) map_keymap_sorted_closure; - Lisp_Object key, contents; Lisp_Object *list = cl->result_locative; - CVOID_TO_LISP (key, hash_key); - VOID_TO_LISP (contents, hash_contents); - *list = Fcons (Fcons (key, contents), *list); + *list = Fcons (Fcons (key, value), *list); return 0; } @@ -2890,7 +2880,7 @@ map_keymap_sort_predicate (Lisp_Object obj1, Lisp_Object obj2, static void map_keymap_sorted (Lisp_Object keymap_table, unsigned int modifiers, - void (*function) (CONST struct key_data *key, + void (*function) (const struct key_data *key, Lisp_Object binding, void *map_keymap_sorted_closure), void *map_keymap_sorted_closure) @@ -2899,7 +2889,7 @@ map_keymap_sorted (Lisp_Object keymap_table, struct gcpro gcpro1; Lisp_Object contents = Qnil; - if (XINT (Fhashtable_fullness (keymap_table)) == 0) + if (XINT (Fhash_table_count (keymap_table)) == 0) return; GCPRO1 (contents); @@ -2935,7 +2925,7 @@ map_keymap_sorted (Lisp_Object keymap_table, /* used by Fmap_keymap() */ static void -map_keymap_mapper (CONST struct key_data *key, +map_keymap_mapper (const struct key_data *key, Lisp_Object binding, void *function) { @@ -2948,7 +2938,7 @@ map_keymap_mapper (CONST struct key_data *key, static void map_keymap (Lisp_Object keymap_table, int sort_first, - void (*function) (CONST struct key_data *key, + void (*function) (const struct key_data *key, Lisp_Object binding, void *fn_arg), void *fn_arg) @@ -3104,23 +3094,28 @@ then the value includes only maps for prefixes that start with PREFIX. c.tail = Qnil; GCPRO4 (accessible_keymaps, c.tail, prefix, keymap); - retry: keymap = get_keymap (keymap, 1, 1); + + retry: if (NILP (prefix)) - prefix = make_vector (0, Qnil); - else if (!VECTORP (prefix) || STRINGP (prefix)) { - prefix = wrong_type_argument (Qarrayp, prefix); - goto retry; + prefix = make_vector (0, Qnil); } - else + else if (VECTORP (prefix) || STRINGP (prefix)) { int len = XINT (Flength (prefix)); - Lisp_Object def = Flookup_key (keymap, prefix, Qnil); + Lisp_Object def; Lisp_Object p; int iii; struct gcpro ngcpro1; + if (len == 0) + { + prefix = Qnil; + goto retry; + } + + def = Flookup_key (keymap, prefix, Qnil); def = get_keymap (def, 0, 1); if (!KEYMAPP (def)) goto RETURN; @@ -3137,12 +3132,16 @@ then the value includes only maps for prefixes that start with PREFIX. NUNGCPRO; prefix = p; } + else + { + prefix = wrong_type_argument (Qarrayp, prefix); + goto retry; + } accessible_keymaps = list1 (Fcons (prefix, keymap)); - /* For each map in the list maps, - look at any other maps it points to - and stick them at the end if they are not already in the list */ + /* For each map in the list maps, look at any other maps it points + to and stick them at the end if they are not already in the list */ for (c.tail = accessible_keymaps; !NILP (c.tail); @@ -3187,9 +3186,9 @@ spaces are put between sequence elements, etc... for (i = 0; i < size; i++) { Lisp_Object s2 = Fsingle_key_description - (((STRINGP (keys)) - ? make_char (string_char (XSTRING (keys), i)) - : XVECTOR_DATA (keys)[i])); + (STRINGP (keys) + ? make_char (string_char (XSTRING (keys), i)) + : XVECTOR_DATA (keys)[i]); if (i == 0) string = s2; @@ -3220,7 +3219,7 @@ of a key read from the user rather than a character from a buffer. char buf [255]; if (!EVENTP (key)) { - struct Lisp_Event event; + Lisp_Event event; event.event_type = empty_event; CHECK_CHAR_COERCE_INT (key); character_to_event (XCHAR (key), &event, @@ -3269,7 +3268,7 @@ of a key read from the user rather than a character from a buffer. #endif strcpy (bufp, (char *) string_data (XSYMBOL (keysym)->name)); if (!NILP (XCDR (rest))) - signal_simple_error ("invalid key description", + signal_simple_error ("Invalid key description", key); } } @@ -3469,7 +3468,7 @@ static void format_raw_keys (struct key_data *keys, int count, char *buf) { int i; - struct Lisp_Event event; + Lisp_Event event; event.event_type = key_press_event; event.channel = Vselected_console; for (i = 0; i < count; i++) @@ -3526,9 +3525,9 @@ where_is_recursive_mapper (Lisp_Object map, void *arg) /* This function can GC */ struct where_is_closure *c = (struct where_is_closure *) arg; Lisp_Object definition = c->definition; - CONST int firstonly = c->firstonly; - CONST unsigned int keys_count = c->keys_count; - CONST unsigned int modifiers_so_far = c->modifiers_so_far; + const int firstonly = c->firstonly; + const unsigned int keys_count = c->keys_count; + const unsigned int modifiers_so_far = c->modifiers_so_far; char *target_buffer = c->target_buffer; Lisp_Object keys = Fgethash (definition, XKEYMAP (map)->inverse_table, @@ -3546,7 +3545,7 @@ where_is_recursive_mapper (Lisp_Object map, void *arg) for (;;) /* loop over all keys that match */ { - Lisp_Object k = ((CONSP (keys)) ? XCAR (keys) : keys); + Lisp_Object k = CONSP (keys) ? XCAR (keys) : keys; int i; so_far [keys_count].keysym = k; @@ -3644,7 +3643,7 @@ where_is_recursive_mapper (Lisp_Object map, void *arg) if (! c->keys_so_far_malloced) { struct key_data *new = xnew_array (struct key_data, size); - memcpy ((void *)new, (CONST void *)c->keys_so_far, + memcpy ((void *)new, (const void *)c->keys_so_far, c->keys_so_far_total_size * sizeof (struct key_data)); } else @@ -3752,7 +3751,7 @@ Fifth argument MOUSE-ONLY-P says to only print bindings for mouse clicks. } -/* Insert a desription of the key bindings in STARTMAP, +/* Insert a description of the key bindings in STARTMAP, followed by those of all maps reachable through STARTMAP. If PARTIAL is nonzero, omit certain "uninteresting" commands (such as `undefined'). @@ -3897,7 +3896,7 @@ struct describe_map_closure struct describe_map_shadow_closure { - CONST struct key_data *raw_key; + const struct key_data *raw_key; Lisp_Object self; }; @@ -3926,7 +3925,7 @@ keymap_lookup_inherited_mapper (Lisp_Object km, void *arg) static void -describe_map_mapper (CONST struct key_data *key, +describe_map_mapper (const struct key_data *key, Lisp_Object binding, void *describe_map_closure) { @@ -3936,7 +3935,7 @@ describe_map_mapper (CONST struct key_data *key, Lisp_Object keysym = key->keysym; unsigned int modifiers = key->modifiers; - /* Dont mention suppressed commands. */ + /* Don't mention suppressed commands. */ if (SYMBOLP (binding) && !NILP (closure->partial) && !NILP (Fget (binding, closure->partial, Qnil))) @@ -4143,7 +4142,7 @@ describe_map (Lisp_Object keymap, Lisp_Object elt_prefix, { Lisp_Object code = Fget (keysym, Vcharacter_set_property, Qnil); Emchar c = (CHAR_OR_CHAR_INTP (code) - ? XCHAR_OR_CHAR_INT (code) : -1); + ? XCHAR_OR_CHAR_INT (code) : (Emchar) -1); /* Calling Fsingle_key_description() would cons more */ #if 0 /* This is bogus */ if (EQ (keysym, QKlinefeed)) @@ -4205,6 +4204,8 @@ describe_map (Lisp_Object keymap, Lisp_Object elt_prefix, void syms_of_keymap (void) { + INIT_LRECORD_IMPLEMENTATION (keymap); + defsymbol (&Qminor_mode_map_alist, "minor-mode-map-alist"); defsymbol (&Qkeymapp, "keymapp"); @@ -4286,6 +4287,7 @@ syms_of_keymap (void) defsymbol (&QRET, "RET"); defsymbol (&QESC, "ESC"); defsymbol (&QDEL, "DEL"); + defsymbol (&QSPC, "SPC"); defsymbol (&QBS, "BS"); } @@ -4325,10 +4327,12 @@ Keymap of key translations that can override keymaps. This keymap works like `function-key-map', but comes after that, and applies even for keys that have ordinary bindings. */ ); + Vkey_translation_map = Qnil; DEFVAR_LISP ("vertical-divider-map", &Vvertical_divider_map /* Keymap which handles mouse clicks over vertical dividers. */ ); + Vvertical_divider_map = Qnil; DEFVAR_INT ("keymap-tick", &keymap_tick /* Incremented for each change to any keymap. @@ -4337,7 +4341,7 @@ Incremented for each change to any keymap. staticpro (&Vcurrent_global_map); - Vsingle_space_string = make_pure_string ((CONST Bufbyte *) " ", 1, Qnil, 1); + Vsingle_space_string = make_string ((const Bufbyte *) " ", 1); staticpro (&Vsingle_space_string); }