xemacs-beta: src/keymap.c comparison

comparison src/keymap.c @ 398:74fd4e045ea6 r21-2-29

Import from CVS: tag r21-2-29

author	cvs
date	Mon, 13 Aug 2007 11:13:30 +0200
parents	8626e4521993
children	a86b2b5e0111

comparison

equal deleted inserted replaced

-:f4aeb21a5bad
+:74fd4e045ea6
 compatibility.
 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
 map over those submaps.  It does not, however, map over other random
 submaps of the keymap, just the bucky ones.
 distinction between ESC and "meta" even more.  "M-x" is no more a two-
 key sequence than "C-x" is.
 */
-typedef struct Lisp_Keymap
+struct Lisp_Keymap
 {
 struct lcrecord_header header;
-Lisp_Object parents;		/* Keymaps to be searched after this one
+Lisp_Object parents;		/* Keymaps to be searched after this one.
-				 *  An ordered list */
+				   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
+(this overrides parent maps and the
-*   normal global-map lookup). */
+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.
+				   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. */
 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)
 /* 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;
 /* Alist of minor mode variables and keymaps.  */
 static Lisp_Object Qminor_mode_map_alist;
 			  void (*elt_describer) (Lisp_Object, Lisp_Object),
 			  int partial,
 			  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;
 Lisp_Object Qbutton4, Qbutton5, Qbutton6, Qbutton7;
 Lisp_Object Qbutton0up, Qbutton1up, Qbutton2up, Qbutton3up;
 /************************************************************************/
 /*                     The keymap Lisp object                           */
 /************************************************************************/
 static Lisp_Object
-mark_keymap (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_keymap (Lisp_Object obj)
 {
 Lisp_Keymap *keymap = XKEYMAP (obj);
-markobj (keymap->parents);
+mark_object (keymap->parents);
-markobj (keymap->prompt);
+mark_object (keymap->prompt);
-markobj (keymap->inverse_table);
+mark_object (keymap->inverse_table);
-markobj (keymap->sub_maps_cache);
+mark_object (keymap->sub_maps_cache);
-markobj (keymap->default_binding);
+mark_object (keymap->default_binding);
-markobj (keymap->name);
+mark_object (keymap->name);
 return keymap->table;
 }
 static void
 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 0x%x>", keymap->header.uid);
 write_c_string ("#<keymap ", printcharfun);
 if (!NILP (keymap->name))
-print_internal (keymap->name, printcharfun, 1);
+{
-/* #### Yuck!  This is no way to form plural!  --hniksic */
+print_internal (keymap->name, printcharfun, 1);
-sprintf (buf, "%s%d entr%s 0x%x>",
+write_c_string (" ", printcharfun);
-((NILP (keymap->name)) ? "" : " "),
+}
-size,
+sprintf (buf, "size %ld 0x%x>",
-((size == 1) ? "y" : "ies"),
+	   (long) XINT (Fkeymap_fullness (obj)), keymap->header.uid);
-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,
+			       keymap_description,
 			       Lisp_Keymap);
 /************************************************************************/
 /*                Traversing keymaps and their parents                  */
 /************************************************************************/
 gcpro1.nvars = 0;
 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);
 	    }
 	  UNGCPRO;
 	  return result;
 	      return Qnil;          /* Nothing found */
 	    }
 	  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);
 	    }
 	  else
 if (modifiers & 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;
 if (prettify && CHARP (keysym))
 /*                   Low-level keymap-store functions                   */
 /************************************************************************/
 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,
 /* else the list's tail has been modified, so we don't need to
 touch the hash table again (the pointer in there is ok).
 */
 }
+/* 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);
+keysym, prev_def);
-if (NILP (value))
+if (NILP (def))
 {
-keymap->fullness--;
-if (keymap->fullness < 0) abort ();
 Fremhash (keysym, keymap->table);
 }
 else
 {
-if (NILP (prev_value))
+Fputhash (keysym, def, keymap->table);
-	keymap->fullness++;
-Fputhash (keysym, value, keymap->table);
 keymap_store_inverse_internal (keymap->inverse_table,
-keysym, value);
+keysym, def);
 }
 keymap_tick++;
 }
 }
 /* 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;
+Lisp_Keymap *k = XKEYMAP (keymap);
-if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
+assert ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
-| MOD_ALT | MOD_SHIFT)) != 0)
+			 | MOD_ALT | MOD_SHIFT)) == 0);
-abort ();
-k = XKEYMAP (keymap);
 /* If the keysym is a one-character symbol, use the char code instead. */
 if (SYMBOLP (keysym) && string_char_length (XSYMBOL (keysym)->name) == 1)
-{
+keysym = make_char (string_char (XSYMBOL (keysym)->name, 0));
-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;
-}
 if (modifiers & MOD_META)     /* Utterly hateful ESC lossage */
 {
 Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
 				     k->table, Qnil);
 static Lisp_Object
 make_keymap (size_t size)
 {
 Lisp_Object result;
-Lisp_Keymap *keymap = alloc_lcrecord_type (Lisp_Keymap, lrecord_keymap);
+Lisp_Keymap *keymap = alloc_lcrecord_type (Lisp_Keymap, &lrecord_keymap);
 XSETKEYMAP (result, keymap);
 keymap->parents         = Qnil;
 keymap->prompt          = Qnil;
 keymap->table           = Qnil;
 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 */
 {
 keymap->table =
 {
 Lisp_Object idx = Fcdr (object);
 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);
 	  indirection = event.event.key;
 	}
 return object;
 }
 }
 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 */
 return get_keyelt (keymap_lookup_directly (keymap,
 					     key->keysym, key->modifiers),
 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->sub_maps_cache = Qnil; /* No submaps */
 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.
 */
 elisp_maphash (copy_keymap_inverse_mapper, keymap->inverse_table,
 		 &copy_keymap_inverse_closure);
 int fullness;
 Lisp_Object sub_maps;
 struct gcpro gcpro1, gcpro2;
 keymap = get_keymap (keymap, 1, 1);
-fullness = XKEYMAP (keymap)->fullness;
+fullness = XINT (Fhash_table_count (XKEYMAP (keymap)->table));
-sub_maps = keymap_submaps (keymap);
 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));
+	  Lisp_Object bucky_map = XCDR (XCAR (sub_maps));
-	  fullness--; /* don't count bucky maps */
+	  fullness--; /* don't count bucky maps themselves. */
-	  fullness += keymap_fullness (sub_map);
+	  fullness += keymap_fullness (bucky_map);
 	}
 }
 UNGCPRO;
 return fullness;
 }
 	  ("The `shift' modifier may not be applied to ASCII keysyms",
 	   spec);
 }
 else
 {
-signal_simple_error ("Unknown keysym specifier",
+signal_simple_error ("Unknown keysym specifier", *keysym);
-			   *keysym);
 }
 if (SYMBOLP (*keysym))
 {
-char *name = (char *)
+char *name = (char *) string_data (XSYMBOL (*keysym)->name);
-	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
 	 confusion, notice the M-x syntax and signal an error - because
 	 otherwise it would be interpreted as a regular keysym, and would even
 	*keysym = QKreturn;
 else if (EQ (*keysym, QESC))
 	*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 */
 else if (EQ(*keysym, Qdown_mouse_1))
 	*keysym = Qbutton1;
 static void
 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);
 returned_value->keysym    = event.event.key.keysym;
 returned_value->modifiers = event.event.key.modifiers;
 XEVENT (event)->event.key.modifiers = raw_key.modifiers;
 }
 int
-event_matches_key_specifier_p (struct Lisp_Event *event,
+event_matches_key_specifier_p (Lisp_Event *event, Lisp_Object key_specifier)
-			       Lisp_Object key_specifier)
 {
 Lisp_Object event2;
 int retval;
 struct gcpro gcpro1;
 UNGCPRO;
 return retval;
 }
 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;
 event.event.key.keysym = key->keysym;
 event.event.key.modifiers = key->modifiers;
 		 (define-key my-map "\M-a" 'my-command)
 		 and then perhaps
 		 (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),
+meta_map = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
-XKEYMAP (keymap)->table, Qnil);
+				   XKEYMAP (keymap)->table, Qnil);
-	      if (!NILP (mmap)
+	      if (!NILP (meta_map)
-		  && keymap_fullness (mmap) != 0)
+		  && keymap_fullness (meta_map) != 0)
-		{
+		signal_simple_error_2
-Lisp_Object desc
+		  ("Map contains meta-bindings, can't bind",
-= Fsingle_key_description (Vmeta_prefix_char);
+		   Fsingle_key_description (Vmeta_prefix_char), keymap);
-		  signal_simple_error_2
-		    ("Map contains meta-bindings, can't bind", desc, keymap);
-		}
 NUNGCPRO;
 	    }
 	  else
 	    {
 	      metized = 1;
 	  raw_key2.modifiers = 0;
 	}
 if (metized)
 	{
-	  raw_key1.modifiers  |= MOD_META;
+	  raw_key1.modifiers |= MOD_META;
 	  raw_key2.modifiers |= MOD_META;
 	  metized = 0;
 	}
 /* This crap is to make sure that someone doesn't bind something like
 to make where-is-internal really fly. */
 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;
 };
 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 */
 struct raw_lookup_key_mapper_closure c;
 c.remaining = raw_keys_count - 1;
 struct raw_lookup_key_mapper_closure *c =
 (struct raw_lookup_key_mapper_closure *) 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])))
 {
 /* Normal case: every case except the meta-hack (see below). */
 int i;
 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);
 for (i = 0; i < nkeys; i++)
 CHECK_LIVE_EVENT (event_head);
 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);
 nkeys = 0;
 							    buffer);
 		  get_relevant_extent_keymaps
 		    (Fevent_modeline_position (terminal),
 		     XBUFFER (buffer)->generated_modeline_string,
-		     /* #### third arg should maybe be a glyph. */
+		     Fevent_glyph_extent (terminal), &closure);
-		     Qnil, &closure);
 		  if (!UNBOUNDP (map) && !NILP (map))
 		    relevant_map_push (get_keymap (map, 1, 1), &closure);
 		}
 	      else
 outside of this file doesn't need to know about.
 */
 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() */
 /* used by map_keymap() */
 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)
 {
 /* This function can GC */
 }
 /* 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)
 {
 /* This function can GC */
 Lisp_Object fn;
 }
 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)
 {
 /* This function can GC */
 Lisp_Object accessible_keymaps = Qnil;
 struct accessible_keymaps_closure c;
 c.tail = Qnil;
 GCPRO4 (accessible_keymaps, c.tail, prefix, keymap);
+keymap = get_keymap (keymap, 1, 1);
 retry:
-keymap = get_keymap (keymap, 1, 1);
 if (NILP (prefix))
-prefix = make_vector (0, Qnil);
+{
-else if (!VECTORP (prefix) || STRINGP (prefix))
+prefix = make_vector (0, Qnil);
-{
+}
-prefix = wrong_type_argument (Qarrayp, prefix);
+else if (VECTORP (prefix) || STRINGP (prefix))
-goto retry;
-}
-else
 {
 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;
 keymap = def;
 	  XVECTOR_DATA (p)[iii] = make_key_description (&key, 1);
 	}
 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,
+/* For each map in the list maps, look at any other maps it points
-look at any other maps it points to
+to and stick them at the end if they are not already in the list */
-and stick them at the end if they are not already in the list */
 for (c.tail = accessible_keymaps;
 !NILP (c.tail);
 c.tail = XCDR (c.tail))
 {
 int i;
 for (i = 0; i < size; i++)
 	{
 	  Lisp_Object s2 = Fsingle_key_description
-	    (((STRINGP (keys))
+	    (STRINGP (keys)
-	      ? make_char (string_char (XSTRING (keys), i))
+	     ? make_char (string_char (XSTRING (keys), i))
-	      : XVECTOR_DATA (keys)[i]));
+	     : XVECTOR_DATA (keys)[i]);
 	  if (i == 0)
 	    string = s2;
 	  else
 	    {
 if (EVENTP (key) || CHAR_OR_CHAR_INTP (key))
 {
 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,
 			      XCONSOLE (Vselected_console), 0, 1);
 	  format_event_object (buf, &event, 1);
 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++)
 {
 event.event.key.keysym    = keys[i].keysym;
 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 int firstonly = c->firstonly;
-CONST unsigned int keys_count = c->keys_count;
+const unsigned int keys_count = c->keys_count;
-CONST unsigned int modifiers_so_far = c->modifiers_so_far;
+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,
 Qnil);
 Lisp_Object submaps;
 	 raw_lookup_key() means undefined.  */
 struct key_data *so_far = c->keys_so_far;
 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;
 	  so_far [keys_count].modifiers = modifiers_so_far;
 	{
 	  int size = lower_keys_count + 50;
 	  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
 	    XREALLOC_ARRAY (c->keys_so_far, struct key_data, size);
 int mice_only_p;	 /* whether we are to display only button bindings */
 };
 struct describe_map_shadow_closure
 {
-CONST struct key_data *raw_key;
+const struct key_data *raw_key;
 Lisp_Object self;
 };
 static Lisp_Object
 describe_map_mapper_shadow_search (Lisp_Object map, void *arg)
 return keymap_lookup_directly (km, k->keysym, k->modifiers);
 }
 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)
 {
 /* This function can GC */
 struct describe_map_closure *closure =
 defsymbol (&QLFD, "LFD");
 defsymbol (&QTAB, "TAB");
 defsymbol (&QRET, "RET");
 defsymbol (&QESC, "ESC");
 defsymbol (&QDEL, "DEL");
+defsymbol (&QSPC, "SPC");
 defsymbol (&QBS, "BS");
 }
 void
 vars_of_keymap (void)
 */ );
 keymap_tick = 0;
 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);
 }
 void
 complex_vars_of_keymap (void)

Mercurial > hg > xemacs-beta

comparison src/keymap.c @ 398:74fd4e045ea6 r21-2-29