X-Git-Url: http://git.chise.org/gitweb/?p=chise%2Fxemacs-chise.git.1;a=blobdiff_plain;f=src%2Fkeymap.c;h=9cae3ab5ad556d50df457b3f5b6dcd6976622f0f;hp=04b6b466bbd65b558a35e685a1efe397943dc08c;hb=59eec5f21669e81977b5b1fe9bf717cab49cf7fb;hpb=ea1ea793fe6e244ef5555ed983423a204101af13 diff --git a/src/keymap.c b/src/keymap.c index 04b6b46..9cae3ab 100644 --- a/src/keymap.c +++ b/src/keymap.c @@ -37,17 +37,6 @@ Boston, MA 02111-1307, USA. */ #include "insdel.h" #include "keymap.h" #include "window.h" - -#ifdef WINDOWSNT -/* Hmm, under unix we want X modifiers, under NT we want X modifiers if - we are running X and Windows modifiers otherwise. - gak. This is a kludge until we support multiple native GUIs! -*/ -#undef MOD_ALT -#undef MOD_CONTROL -#undef MOD_SHIFT -#endif - #include "events-mod.h" @@ -99,25 +88,25 @@ Boston, MA 02111-1307, USA. */ If the key `C-a' was bound to some command, the hierarchy would look like - keymap-1: associates the integer MOD_CONTROL with keymap-2 + keymap-1: associates the integer XEMACS_MOD_CONTROL with keymap-2 keymap-2: associates "a" with the command Similarly, if the key `C-H-a' was bound to some command, the hierarchy would look like - keymap-1: associates the integer (MOD_CONTROL | MOD_HYPER) + keymap-1: associates the integer (XEMACS_MOD_CONTROL | XEMACS_MOD_HYPER) with keymap-2 keymap-2: associates "a" with the command Note that a special exception is made for the meta modifier, in order to deal with ESC/meta lossage. Any key combination containing the meta modifier is first indexed off of the main map into the meta - submap (with hash key MOD_META) and then indexed off of the + submap (with hash key XEMACS_MOD_META) and then indexed off of the meta submap with the meta modifier removed from the key combination. For example, when associating a command with C-M-H-a, we'd have - keymap-1: associates the integer MOD_META with keymap-2 - keymap-2: associates the integer (MOD_CONTROL | MOD_HYPER) + keymap-1: associates the integer XEMACS_MOD_META with keymap-2 + keymap-2: associates the integer (XEMACS_MOD_CONTROL | XEMACS_MOD_HYPER) with keymap-3 keymap-3: associates "a" with the command @@ -131,7 +120,7 @@ Boston, MA 02111-1307, USA. */ Note that this new model of keymaps takes much of the magic away from the Escape key: the value of the variable `esc-map' is no longer indexed in the `global-map' under the ESC key. It's indexed under the integer - MOD_META. This is not user-visible, however; none of the "bucky" + XEMACS_MOD_META. This is not user-visible, however; none of the "bucky" maps are. There is a hack in Flookup_key() that makes (lookup-key global-map "\^[") @@ -141,7 +130,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 @@ -156,33 +145,25 @@ Boston, MA 02111-1307, USA. */ */ -typedef struct Lisp_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 */ -} Lisp_Keymap; +}; #define MAKE_MODIFIER_HASH_KEY(modifier) make_int (modifier) #define MODIFIER_HASH_KEY_BITS(x) (INTP (x) ? XINT (x) : 0) @@ -191,7 +172,7 @@ typedef struct Lisp_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; @@ -230,6 +211,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; @@ -270,24 +252,27 @@ print_keymap (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) /* This function can GC */ 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), 6 }, - { XD_LISP_OBJECT, offsetof(Lisp_Keymap, name), 1 }, + { 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 } }; @@ -319,19 +304,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); } @@ -348,7 +333,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); @@ -410,40 +395,40 @@ traverse_keymaps (Lisp_Object start_keymap, Lisp_Object start_parents, /* Some low-level functions */ /************************************************************************/ -static unsigned int +static int bucky_sym_to_bucky_bit (Lisp_Object sym) { - if (EQ (sym, Qcontrol)) return MOD_CONTROL; - if (EQ (sym, Qmeta)) return MOD_META; - if (EQ (sym, Qsuper)) return MOD_SUPER; - if (EQ (sym, Qhyper)) return MOD_HYPER; - if (EQ (sym, Qalt)) return MOD_ALT; - if (EQ (sym, Qsymbol)) return MOD_ALT; /* #### - reverse compat */ - if (EQ (sym, Qshift)) return MOD_SHIFT; + if (EQ (sym, Qcontrol)) return XEMACS_MOD_CONTROL; + if (EQ (sym, Qmeta)) return XEMACS_MOD_META; + if (EQ (sym, Qsuper)) return XEMACS_MOD_SUPER; + if (EQ (sym, Qhyper)) return XEMACS_MOD_HYPER; + if (EQ (sym, Qalt)) return XEMACS_MOD_ALT; + if (EQ (sym, Qsymbol)) return XEMACS_MOD_ALT; /* #### - reverse compat */ + if (EQ (sym, Qshift)) return XEMACS_MOD_SHIFT; return 0; } static Lisp_Object -control_meta_superify (Lisp_Object frob, unsigned int modifiers) +control_meta_superify (Lisp_Object frob, int modifiers) { if (modifiers == 0) return frob; frob = Fcons (frob, Qnil); - if (modifiers & MOD_SHIFT) frob = Fcons (Qshift, frob); - if (modifiers & MOD_ALT) frob = Fcons (Qalt, frob); - if (modifiers & MOD_HYPER) frob = Fcons (Qhyper, frob); - if (modifiers & MOD_SUPER) frob = Fcons (Qsuper, frob); - if (modifiers & MOD_CONTROL) frob = Fcons (Qcontrol, frob); - if (modifiers & MOD_META) frob = Fcons (Qmeta, frob); + if (modifiers & XEMACS_MOD_SHIFT) frob = Fcons (Qshift, frob); + if (modifiers & XEMACS_MOD_ALT) frob = Fcons (Qalt, frob); + if (modifiers & XEMACS_MOD_HYPER) frob = Fcons (Qhyper, frob); + if (modifiers & XEMACS_MOD_SUPER) frob = Fcons (Qsuper, frob); + if (modifiers & XEMACS_MOD_CONTROL) frob = Fcons (Qcontrol, frob); + if (modifiers & XEMACS_MOD_META) frob = Fcons (Qmeta, frob); return frob; } 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; + int modifiers = key->modifiers; if (prettify && CHARP (keysym)) { @@ -468,18 +453,21 @@ 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 */ static Lisp_Object keymap_lookup_directly (Lisp_Object keymap, - Lisp_Object keysym, unsigned int modifiers) + Lisp_Object keysym, int modifiers) { Lisp_Keymap *k; - if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER - | MOD_ALT | MOD_SHIFT)) != 0) + modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3 + | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5); + if ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER + | XEMACS_MOD_HYPER | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT)) + != 0) abort (); k = XKEYMAP (keymap); @@ -492,14 +480,14 @@ keymap_lookup_directly (Lisp_Object keymap, keysym = i_fart_on_gcc; } - if (modifiers & MOD_META) /* Utterly hateful ESC lossage */ + if (modifiers & XEMACS_MOD_META) /* Utterly hateful ESC lossage */ { - Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META), + Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META), k->table, Qnil); if (NILP (submap)) return Qnil; k = XKEYMAP (submap); - modifiers &= ~MOD_META; + modifiers &= ~XEMACS_MOD_META; } if (modifiers != 0) @@ -583,38 +571,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, Lisp_Keymap *keymap, - Lisp_Object value) + 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 (Lisp_Keymap *k, unsigned int modifiers, +create_bucky_submap (Lisp_Keymap *k, int modifiers, Lisp_Object parent_for_debugging_info) { Lisp_Object submap = Fmake_sparse_keymap (Qnil); @@ -630,35 +637,31 @@ create_bucky_submap (Lisp_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; - Lisp_Keymap *k; - - if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER - | MOD_ALT | MOD_SHIFT)) != 0) - abort (); + int modifiers = key->modifiers; + Lisp_Keymap *k = XKEYMAP (keymap); - k = XKEYMAP (keymap); + modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3 + | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5); + assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META + | XEMACS_MOD_SUPER | XEMACS_MOD_HYPER + | XEMACS_MOD_ALT | XEMACS_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 */ + if (modifiers & XEMACS_MOD_META) /* Utterly hateful ESC lossage */ { - Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META), + Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META), k->table, Qnil); if (NILP (submap)) - submap = create_bucky_submap (k, MOD_META, keymap); + submap = create_bucky_submap (k, XEMACS_MOD_META, keymap); k = XKEYMAP (submap); - modifiers &= ~MOD_META; + modifiers &= ~XEMACS_MOD_META; } if (modifiers != 0) @@ -759,7 +762,6 @@ make_keymap (size_t size) keymap->inverse_table = Qnil; keymap->default_binding = Qnil; keymap->sub_maps_cache = Qnil; /* No possible submaps */ - keymap->fullness = 0; keymap->name = Qnil; if (size != 0) /* hack for copy-keymap */ @@ -1051,7 +1053,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); @@ -1062,7 +1064,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)) { @@ -1093,7 +1095,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 */ @@ -1137,7 +1139,6 @@ copy_keymap_internal (Lisp_Keymap *keymap) copy_keymap_inverse_closure.inverse_table = keymap->inverse_table; new_keymap->parents = Fcopy_sequence (keymap->parents); - new_keymap->fullness = keymap->fullness; new_keymap->sub_maps_cache = Qnil; /* No submaps */ new_keymap->table = Fcopy_hash_table (keymap->table); new_keymap->inverse_table = Fcopy_hash_table (keymap->inverse_table); @@ -1215,16 +1216,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; @@ -1251,7 +1253,7 @@ Return the number of bindings in the keymap. static void define_key_check_and_coerce_keysym (Lisp_Object spec, Lisp_Object *keysym, - unsigned int modifiers) + int modifiers) { /* Now, check and massage the trailing keysym specifier. */ if (SYMBOLP (*keysym)) @@ -1274,21 +1276,19 @@ define_key_check_and_coerce_keysym (Lisp_Object spec, problems ... */ signal_simple_error ("keysym char must be printable", *keysym); /* #### This bites! I want to be able to write (control shift a) */ - if (modifiers & MOD_SHIFT) + if (modifiers & XEMACS_MOD_SHIFT) signal_simple_error ("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 @@ -1392,7 +1392,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); @@ -1453,14 +1453,14 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value) } else if (CONSP (spec)) { - unsigned int modifiers = 0; + int modifiers = 0; Lisp_Object keysym = Qnil; Lisp_Object rest = spec; /* First, parse out the leading modifier symbols. */ while (CONSP (rest)) { - unsigned int modifier; + int modifier; keysym = XCAR (rest); modifier = bucky_sym_to_bucky_bit (keysym); @@ -1540,8 +1540,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; @@ -1592,9 +1591,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; @@ -1631,12 +1630,12 @@ define_key_alternate_name (struct key_data *key, struct key_data *returned_value) { Lisp_Object keysym = key->keysym; - unsigned int modifiers = key->modifiers; - unsigned int modifiers_sans_control = (modifiers & (~MOD_CONTROL)); - unsigned int modifiers_sans_meta = (modifiers & (~MOD_META)); + int modifiers = key->modifiers; + int modifiers_sans_control = (modifiers & (~XEMACS_MOD_CONTROL)); + int modifiers_sans_meta = (modifiers & (~XEMACS_MOD_META)); returned_value->keysym = Qnil; /* By default, no "alternate" key */ returned_value->modifiers = 0; - if (modifiers_sans_meta == MOD_CONTROL) + if (modifiers_sans_meta == XEMACS_MOD_CONTROL) { if EQ (keysym, QKspace) MACROLET (make_char ('@'), modifiers); @@ -1663,15 +1662,15 @@ define_key_alternate_name (struct key_data *key, else if (modifiers_sans_meta != 0) return; else if (EQ (keysym, QKbackspace)) /* backspace => c-h */ - MACROLET (make_char ('h'), (modifiers | MOD_CONTROL)); + MACROLET (make_char ('h'), (modifiers | XEMACS_MOD_CONTROL)); else if (EQ (keysym, QKtab)) /* tab => c-i */ - MACROLET (make_char ('i'), (modifiers | MOD_CONTROL)); + MACROLET (make_char ('i'), (modifiers | XEMACS_MOD_CONTROL)); else if (EQ (keysym, QKlinefeed)) /* linefeed => c-j */ - MACROLET (make_char ('j'), (modifiers | MOD_CONTROL)); + MACROLET (make_char ('j'), (modifiers | XEMACS_MOD_CONTROL)); else if (EQ (keysym, QKreturn)) /* return => c-m */ - MACROLET (make_char ('m'), (modifiers | MOD_CONTROL)); + MACROLET (make_char ('m'), (modifiers | XEMACS_MOD_CONTROL)); else if (EQ (keysym, QKescape)) /* escape => c-[ */ - MACROLET (make_char ('['), (modifiers | MOD_CONTROL)); + MACROLET (make_char ('['), (modifiers | XEMACS_MOD_CONTROL)); else return; #undef MACROLET @@ -1708,7 +1707,10 @@ ensure_meta_prefix_char_keymapp (Lisp_Object keys, int indx, XVECTOR_DATA (new_keys) [i] = XVECTOR_DATA (keys) [i]; } else - abort (); + { + new_keys = Qnil; + abort (); + } if (EQ (keys, new_keys)) error_with_frob (mpc_binding, @@ -1900,20 +1902,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 (XEMACS_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 @@ -1934,14 +1933,14 @@ these features. if (metized) { - raw_key1.modifiers |= MOD_META; - raw_key2.modifiers |= MOD_META; + raw_key1.modifiers |= XEMACS_MOD_META; + raw_key2.modifiers |= XEMACS_MOD_META; metized = 0; } /* This crap is to make sure that someone doesn't bind something like "C-x M-a" while "C-x ESC" has a non-keymap binding. */ - if (raw_key1.modifiers & MOD_META) + if (raw_key1.modifiers & XEMACS_MOD_META) ensure_meta_prefix_char_keymapp (keys, idx, keymap); if (++idx == len) @@ -1991,7 +1990,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; @@ -2002,7 +2001,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 */ @@ -2025,7 +2024,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]))) @@ -2064,7 +2063,7 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg) if (NILP (cmd)) { /* Do kludgy return of the meta-map */ - cmd = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META), + cmd = Fgethash (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META), XKEYMAP (k)->table, Qnil); } } @@ -2076,11 +2075,12 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg) if (!NILP (cmd)) cmd = raw_lookup_key (cmd, raw_keys + 1, remaining, keys_so_far + 1, accept_default); - else if ((raw_keys[1].modifiers & MOD_META) == 0) + else if ((raw_keys[1].modifiers & XEMACS_MOD_META) == 0) { struct key_data metified; metified.keysym = raw_keys[1].keysym; - metified.modifiers = raw_keys[1].modifiers | MOD_META; + metified.modifiers = raw_keys[1].modifiers | + (unsigned char) XEMACS_MOD_META; /* Search for meta-next-char sequence directly */ cmd = keymap_lookup_1 (k, &metified, accept_default); @@ -2116,7 +2116,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); @@ -2146,7 +2146,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); @@ -2372,8 +2372,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); @@ -2741,9 +2740,9 @@ 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; + int modifiers; }; /* used by map_keymap() */ @@ -2754,8 +2753,8 @@ map_keymap_unsorted_mapper (Lisp_Object keysym, Lisp_Object value, /* This function can GC */ struct map_keymap_unsorted_closure *closure = (struct map_keymap_unsorted_closure *) map_keymap_unsorted_closure; - unsigned int modifiers = closure->modifiers; - unsigned int mod_bit; + int modifiers = closure->modifiers; + int mod_bit; mod_bit = MODIFIER_HASH_KEY_BITS (keysym); if (mod_bit != 0) { @@ -2805,7 +2804,7 @@ map_keymap_sort_predicate (Lisp_Object obj1, Lisp_Object obj2, { /* obj1 and obj2 are conses with keysyms in their cars. Cdrs are ignored. */ - unsigned int bit1, bit2; + int bit1, bit2; int sym1_p = 0; int sym2_p = 0; obj1 = XCAR (obj1); @@ -2879,8 +2878,8 @@ map_keymap_sort_predicate (Lisp_Object obj1, Lisp_Object obj2, /* used by map_keymap() */ static void map_keymap_sorted (Lisp_Object keymap_table, - unsigned int modifiers, - void (*function) (CONST struct key_data *key, + int modifiers, + void (*function) (const struct key_data *key, Lisp_Object binding, void *map_keymap_sorted_closure), void *map_keymap_sorted_closure) @@ -2904,7 +2903,7 @@ map_keymap_sorted (Lisp_Object keymap_table, { Lisp_Object keysym = XCAR (XCAR (contents)); Lisp_Object binding = XCDR (XCAR (contents)); - unsigned int sub_bits = MODIFIER_HASH_KEY_BITS (keysym); + int sub_bits = MODIFIER_HASH_KEY_BITS (keysym); if (sub_bits != 0) map_keymap_sorted (XKEYMAP (get_keymap (binding, 1, 1))->table, @@ -2925,7 +2924,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) { @@ -2938,7 +2937,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) @@ -3010,11 +3009,11 @@ struct accessible_keymaps_closure static void accessible_keymaps_mapper_1 (Lisp_Object keysym, Lisp_Object contents, - unsigned int modifiers, + int modifiers, struct accessible_keymaps_closure *closure) { /* This function can GC */ - unsigned int subbits = MODIFIER_HASH_KEY_BITS (keysym); + int subbits = MODIFIER_HASH_KEY_BITS (keysym); if (subbits != 0) { @@ -3094,23 +3093,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; @@ -3127,12 +3131,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); @@ -3210,7 +3218,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, @@ -3459,7 +3467,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++) @@ -3483,7 +3491,7 @@ format_raw_keys (struct key_data *keys, int count, char *buf) keys_so_far and modifiers_so_far describe which map we're looking in; If we're in the "meta" submap of the map that "C-x 4" is bound to, then keys_so_far will be {(control x), \4}, and modifiers_so_far - will be MOD_META. That is, keys_so_far is the chain of keys that we + will be XEMACS_MOD_META. That is, keys_so_far is the chain of keys that we have followed, and modifiers_so_far_so_far is the bits (partial keys) beyond that. @@ -3501,7 +3509,7 @@ struct where_is_closure int shadow_count; int firstonly; int keys_count; - unsigned int modifiers_so_far; + int modifiers_so_far; char *target_buffer; struct key_data *keys_so_far; int keys_so_far_total_size; @@ -3516,9 +3524,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 int keys_count = c->keys_count; + const int modifiers_so_far = c->modifiers_so_far; char *target_buffer = c->target_buffer; Lisp_Object keys = Fgethash (definition, XKEYMAP (map)->inverse_table, @@ -3591,9 +3599,9 @@ where_is_recursive_mapper (Lisp_Object map, void *arg) { Lisp_Object key = XCAR (XCAR (submaps)); Lisp_Object submap = XCDR (XCAR (submaps)); - unsigned int lower_modifiers; + int lower_modifiers; int lower_keys_count = keys_count; - unsigned int bucky; + int bucky; submap = get_keymap (submap, 0, 0); @@ -3634,7 +3642,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 @@ -3887,7 +3895,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; }; @@ -3916,7 +3924,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) { @@ -3924,7 +3932,7 @@ describe_map_mapper (CONST struct key_data *key, struct describe_map_closure *closure = (struct describe_map_closure *) describe_map_closure; Lisp_Object keysym = key->keysym; - unsigned int modifiers = key->modifiers; + int modifiers = key->modifiers; /* Don't mention suppressed commands. */ if (SYMBOLP (binding) @@ -3998,7 +4006,7 @@ describe_map_sort_predicate (Lisp_Object obj1, Lisp_Object obj2, ( ( . ) . ) keysym and modifiers are used, binding is ignored. */ - unsigned int bit1, bit2; + int bit1, bit2; obj1 = XCAR (obj1); obj2 = XCAR (obj2); bit1 = XINT (XCDR (obj1)); @@ -4118,17 +4126,23 @@ describe_map (Lisp_Object keymap, Lisp_Object elt_prefix, { Lisp_Object elt = XCAR (XCAR (list)); Lisp_Object keysym = XCAR (elt); - unsigned int modifiers = XINT (XCDR (elt)); + int modifiers = XINT (XCDR (elt)); if (!NILP (elt_prefix)) buffer_insert_lisp_string (buf, elt_prefix); - if (modifiers & MOD_META) buffer_insert_c_string (buf, "M-"); - if (modifiers & MOD_CONTROL) buffer_insert_c_string (buf, "C-"); - if (modifiers & MOD_SUPER) buffer_insert_c_string (buf, "S-"); - if (modifiers & MOD_HYPER) buffer_insert_c_string (buf, "H-"); - if (modifiers & MOD_ALT) buffer_insert_c_string (buf, "Alt-"); - if (modifiers & MOD_SHIFT) buffer_insert_c_string (buf, "Sh-"); + if (modifiers & XEMACS_MOD_META) + buffer_insert_c_string (buf, "M-"); + if (modifiers & XEMACS_MOD_CONTROL) + buffer_insert_c_string (buf, "C-"); + if (modifiers & XEMACS_MOD_SUPER) + buffer_insert_c_string (buf, "S-"); + if (modifiers & XEMACS_MOD_HYPER) + buffer_insert_c_string (buf, "H-"); + if (modifiers & XEMACS_MOD_ALT) + buffer_insert_c_string (buf, "Alt-"); + if (modifiers & XEMACS_MOD_SHIFT) + buffer_insert_c_string (buf, "Sh-"); if (SYMBOLP (keysym)) { Lisp_Object code = Fget (keysym, Vcharacter_set_property, Qnil); @@ -4195,6 +4209,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"); @@ -4330,7 +4346,7 @@ Incremented for each change to any keymap. staticpro (&Vcurrent_global_map); - Vsingle_space_string = make_string ((CONST Bufbyte *) " ", 1); + Vsingle_space_string = make_string ((const Bufbyte *) " ", 1); staticpro (&Vsingle_space_string); } @@ -4346,7 +4362,7 @@ complex_vars_of_keymap (void) meta_disgustitute = Fmake_keymap (Qnil); Ffset (ESC_prefix, meta_disgustitute); /* no need to protect meta_disgustitute, though */ - keymap_store_internal (MAKE_MODIFIER_HASH_KEY (MOD_META), + keymap_store_internal (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META), XKEYMAP (Vcurrent_global_map), meta_disgustitute); XKEYMAP (Vcurrent_global_map)->sub_maps_cache = Qt;