xemacs-beta: src/keymap.c comparison

comparison src/keymap.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	28f395d8dc7a
children	2d532a89d707

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 ((markobj) (keymap->prompt));
 ((markobj) (keymap->inverse_table));
 ((markobj) (keymap->sub_maps_cache));
 ((markobj) (keymap->default_binding));
 ((markobj) (keymap->name));
-return (keymap->table);
+return keymap->table;
 }
 static void
 print_keymap (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 	      struct Lisp_Cons *victim = XCONS (malloc_bites);
 	      malloc_bites = victim->cdr;
 	      free_cons (victim);
 	    }
 	  UNGCPRO;
-	  return (result);
+	  return result;
 	}
 if (NILP (tail))
 	{
 	  if (stack_depth == 0)
 	    {
 	      UNGCPRO;
-	      return (Qnil);          /* Nothing found */
+	      return Qnil;          /* Nothing found */
 	    }
 	  stack_depth--;
 	  if (CONSP (malloc_bites))
 	    {
 	      struct Lisp_Cons *victim = XCONS (malloc_bites);
 control_meta_superify (Lisp_Object frob, unsigned int modifiers)
 {
 if (modifiers == 0)
 return frob;
 frob = Fcons (frob, Qnil);
-if (modifiers & MOD_SHIFT)
+if (modifiers & MOD_SHIFT)   frob = Fcons (Qshift,   frob);
-frob = Fcons (Qshift, frob);
+if (modifiers & MOD_ALT)     frob = Fcons (Qalt,     frob);
-if (modifiers & MOD_ALT)
+if (modifiers & MOD_HYPER)   frob = Fcons (Qhyper,   frob);
-frob = Fcons (Qalt, frob);
+if (modifiers & MOD_SUPER)   frob = Fcons (Qsuper,   frob);
-if (modifiers & MOD_HYPER)
+if (modifiers & MOD_CONTROL) frob = Fcons (Qcontrol, frob);
-frob = Fcons (Qhyper, frob);
+if (modifiers & MOD_META)    frob = Fcons (Qmeta,    frob);
-if (modifiers & MOD_SUPER)
+return frob;
-frob = Fcons (Qsuper, frob);
-if (modifiers & MOD_CONTROL)
-frob = Fcons (Qcontrol, frob);
-if (modifiers & MOD_META)
-frob = Fcons (Qmeta, frob);
-return (frob);
 }
 static Lisp_Object
 make_key_description (CONST struct key_data *key, int prettify)
 {
 Bufbyte str [1 + MAX_EMCHAR_LEN];
 Bytecount count = set_charptr_emchar (str, XCHAR (keysym));
 str[count] = 0;
 keysym = intern ((char *) str);
 }
-return (control_meta_superify (keysym, modifiers));
+return control_meta_superify (keysym, modifiers);
 }
 /************************************************************************/
 /*                   Low-level keymap-store functions                   */
 if (modifiers & MOD_META)     /* Utterly hateful ESC lossage */
 {
 Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
 k->table, Qnil);
 if (NILP (submap))
-return (Qnil);
+return Qnil;
 k = XKEYMAP (submap);
 modifiers &= ~MOD_META;
 }
 if (modifiers != 0)
 {
 Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (modifiers),
 k->table, Qnil);
 if (NILP (submap))
-return (Qnil);
+return Qnil;
 k = XKEYMAP (submap);
 }
-return (Fgethash (keysym, k->table, Qnil));
+return Fgethash (keysym, k->table, Qnil);
 }
 static void
 keymap_store_inverse_internal (Lisp_Object inverse_table,
 Lisp_Object keysym,
 XKEYMAP (submap)->name
 = control_meta_superify (parent_for_debugging_info, modifiers);
 /* Invalidate cache */
 k->sub_maps_cache = Qt;
 keymap_store_internal (MAKE_MODIFIER_HASH_KEY (modifiers), k, submap);
-return (submap);
+return submap;
 }
 /* Relies on caller to gc-protect keymap, keysym, value */
 static void
 k->sub_maps_cache = list_sort (result,
 				     Qnil,
 				     map_keymap_sort_predicate);
 UNGCPRO;
 }
-return (k->sub_maps_cache);
+return k->sub_maps_cache;
 }
 /************************************************************************/
 /*                    Basic operations on keymaps                       */
 /* 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->name = Qnil;
-return (result);
+return result;
 }
 DEFUN ("make-keymap", Fmake_keymap, 0, 1, 0, /*
 Construct and return a new keymap object.
 All entries in it are nil, meaning \"command undefined\".
 of all keymaps.
 */
 (keymap))
 {
 keymap = get_keymap (keymap, 1, 1);
-return (Fcopy_sequence (XKEYMAP (keymap)->parents));
+return Fcopy_sequence (XKEYMAP (keymap)->parents);
 }
 static Lisp_Object
 traverse_keymaps_noop (Lisp_Object keymap, void *arg)
 {
-return (Qnil);
+return Qnil;
 }
 DEFUN ("set-keymap-parents", Fset_keymap_parents, 2, 2, 0, /*
 Sets the `parent' keymaps of the given keymap.
 The parents of a keymap are searched for keybindings when a key sequence
 /* Check for circularities */
 traverse_keymaps (keymap, parents, traverse_keymaps_noop, 0);
 keymap_tick++;
 XKEYMAP (keymap)->parents = Fcopy_sequence (parents);
 UNGCPRO;
-return (parents);
+return parents;
 }
 DEFUN ("set-keymap-name", Fset_keymap_name, 2, 2, 0, /*
 Set the `name' of the KEYMAP to NEW-NAME.
 The name is only a debugging convenience; it is not used except
 (keymap, new_name))
 {
 keymap = get_keymap (keymap, 1, 1);
 XKEYMAP (keymap)->name = new_name;
-return (new_name);
+return new_name;
 }
 DEFUN ("keymap-name", Fkeymap_name, 1, 1, 0, /*
 Return the `name' of KEYMAP.
 The name is only a debugging convenience; it is not used except
 */
 (keymap))
 {
 keymap = get_keymap (keymap, 1, 1);
-return (XKEYMAP (keymap)->name);
+return XKEYMAP (keymap)->name;
 }
 DEFUN ("set-keymap-prompt", Fset_keymap_prompt, 2, 2, 0, /*
 Sets the `prompt' of KEYMAP to string NEW-PROMPT, or `nil'
 if no prompt is desired.  The prompt is shown in the echo-area
 if (!NILP (new_prompt))
 CHECK_STRING (new_prompt);
 XKEYMAP (keymap)->prompt = new_prompt;
-return (new_prompt);
+return new_prompt;
 }
 static Lisp_Object
 keymap_prompt_mapper (Lisp_Object keymap, void *arg)
 {
-return (XKEYMAP (keymap)->prompt);
+return XKEYMAP (keymap)->prompt;
 }
 DEFUN ("keymap-prompt", Fkeymap_prompt, 1, 2, 0, /*
 Return the `prompt' of the given keymap.
 Lisp_Object prompt;
 keymap = get_keymap (keymap, 1, 1);
 prompt = XKEYMAP (keymap)->prompt;
 if (!NILP (prompt) || NILP (use_inherited))
-return (prompt);
+return prompt;
 else
-return (traverse_keymaps (keymap, Qnil,
+return traverse_keymaps (keymap, Qnil, keymap_prompt_mapper, 0);
-			      keymap_prompt_mapper, 0));
 }
 DEFUN ("set-keymap-default-binding", Fset_keymap_default_binding, 2, 2, 0, /*
 Sets the default binding of KEYMAP to COMMAND, or `nil'
 if no default is desired.  The default-binding is returned when
 {
 /* This function can GC */
 keymap = get_keymap (keymap, 1, 1);
 XKEYMAP (keymap)->default_binding = command;
-return (command);
+return command;
 }
 DEFUN ("keymap-default-binding", Fkeymap_default_binding, 1, 1, 0, /*
 Return the default binding of KEYMAP, or `nil' if it has none.
 The default-binding is returned when no other binding for a key-sequence
 */
 (keymap))
 {
 /* This function can GC */
 keymap = get_keymap (keymap, 1, 1);
-return (XKEYMAP (keymap)->default_binding);
+return XKEYMAP (keymap)->default_binding;
 }
 DEFUN ("keymapp", Fkeymapp, 1, 1, 0, /*
 Return t if ARG is a keymap object.
 The keymap may be autoloaded first if necessary.
 */
 (object))
 {
 /* This function can GC */
 Lisp_Object tem = get_keymap (object, 0, 1);
-return ((KEYMAPP (tem)) ? Qt : Qnil);
+return KEYMAPP (tem) ? Qt : Qnil;
 }
 /* Check that OBJECT is a keymap (after dereferencing through any
 symbols).  If it is, return it.
 /* This function can GC */
 Lisp_Object map;
 tail_recurse:
 if (!CONSP (object))
-return (object);
+return object;
 {
 struct gcpro gcpro1;
 GCPRO1 (object);
 map = XCAR (object);
 	  indirection = event.event.key;
 	}
 else if (CONSP (idx))
 	{
 	  if (!INTP (XCDR (idx)))
-	    return (Qnil);
+	    return Qnil;
 	  indirection.keysym = XCAR (idx);
 	  indirection.modifiers = XINT (XCDR (idx));
 	}
 else if (SYMBOLP (idx))
 	{
 	  indirection.modifiers = 0;
 	}
 else
 	{
 	  /* Random junk */
-	  return (Qnil);
+	  return Qnil;
 	}
-return (raw_lookup_key (map, &indirection, 1, 0,
+return raw_lookup_key (map, &indirection, 1, 0, accept_default);
-			      accept_default));
 }
 else if (STRINGP (XCAR (object)))
 {
 /* If the keymap contents looks like (STRING . DEFN),
 	 use DEFN.
 goto tail_recurse;
 }
 else
 {
 /* Anything else is really the value.  */
-return (object);
+return object;
 }
 }
 static Lisp_Object
 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,
+return get_keyelt (keymap_lookup_directly (keymap,
-key->keysym, key->modifiers),
+					     key->keysym, key->modifiers),
-accept_default));
+		     accept_default);
 }
 /************************************************************************/
 /*                          Copying keymaps                             */
 	  fullness--; /* don't count bucky maps */
 	  fullness += keymap_fullness (sub_map);
 	}
 }
 UNGCPRO;
-return (fullness);
+return fullness;
 }
 DEFUN ("keymap-fullness", Fkeymap_fullness, 1, 1, 0, /*
 Return the number of bindings in the keymap.
 */
 (keymap))
 {
 /* This function can GC */
-return (make_int (keymap_fullness
+return make_int (keymap_fullness (get_keymap (keymap, 1, 1)));
-		       (get_keymap (keymap, 1, 1))));
 }
 /************************************************************************/
 /*                        Defining keys in keymaps                      */
 new_keys = Fsubstring (keys, Qzero, make_int (indx));
 else if (VECTORP (keys))
 {
 new_keys = make_vector (indx, Qnil);
 for (i = 0; i < indx; i++)
-	vector_data (XVECTOR (new_keys)) [i] =
+	XVECTOR_DATA (new_keys) [i] = XVECTOR_DATA (keys) [i];
-	  vector_data (XVECTOR (keys)) [i];
 }
 else
 abort ();
 if (EQ (keys, new_keys))
 sprintf (buf, GETTEXT ("can't bind %s: %s has a non-keymap binding"),
 (keymap, keys, def))
 {
 /* This function can GC */
 int idx;
 int metized = 0;
-int size;
+int len;
 int ascii_hack;
 struct gcpro gcpro1, gcpro2, gcpro3;
 if (VECTORP (keys))
-size = vector_length (XVECTOR (keys));
+len = XVECTOR_LENGTH (keys);
 else if (STRINGP (keys))
-size = string_char_length (XSTRING (keys));
+len = string_char_length (XSTRING (keys));
 else if (CHAR_OR_CHAR_INTP (keys) || SYMBOLP (keys) || CONSP (keys))
 {
 if (!CONSP (keys)) keys = list1 (keys);
-size = 1;
+len = 1;
 keys = make_vector (1, keys); /* this is kinda sleazy. */
 }
 else
 {
 keys = wrong_type_argument (Qsequencep, keys);
-size = XINT (Flength (keys));
+len = XINT (Flength (keys));
 }
-if (size == 0)
+if (len == 0)
-return (Qnil);
+return Qnil;
 GCPRO3 (keymap, keys, def);
 /* ASCII grunge.
 When the user defines a key which, in a strictly ASCII world, would be
 struct key_data raw_key2;
 if (STRINGP (keys))
 	c = make_char (string_char (XSTRING (keys), idx));
 else
-	c = vector_data (XVECTOR (keys)) [idx];
+	c = XVECTOR_DATA (keys) [idx];
 define_key_parser (c, &raw_key1);
 if (!metized && ascii_hack && meta_prefix_char_p (&raw_key1))
 	{
-	  if (idx == (size - 1))
+	  if (idx == (len - 1))
 	    {
 	      /* This is a hack to prevent a binding for the meta-prefix-char
 		 from being made in a map which already has a non-empty "meta"
 		 submap.  That is, we can't let both "escape" and "meta" have
 		 a binding in the same keymap.  This implies that the idiom
 /* 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)
 	ensure_meta_prefix_char_keymapp (keys, idx, keymap);
-if (++idx == size)
+if (++idx == len)
 	{
 	  keymap_store (keymap, &raw_key1, def);
 	  if (ascii_hack && !NILP (raw_key2.keysym))
 	    keymap_store (keymap, &raw_key2, def);
 	  UNGCPRO;
 c.raw_keys = raw_keys;
 c.raw_keys_count = raw_keys_count;
 c.keys_so_far = keys_so_far;
 c.accept_default = accept_default;
-return (traverse_keymaps (keymap, Qnil, raw_lookup_key_mapper,
+return traverse_keymaps (keymap, Qnil, raw_lookup_key_mapper, &c);
-			    &c));
 }
 static Lisp_Object
 raw_lookup_key_mapper (Lisp_Object k, void *arg)
 {
 	    }
 	}
 }
 if (accept_default && NILP (cmd))
 cmd = XKEYMAP (k)->default_binding;
-return (cmd);
+return cmd;
 }
 /* Value is number if `keys' is too long; NIL if valid but has no definition.*/
 /* Caller should gc-protect arguments */
 static Lisp_Object
 for (i = 0; i < nkeys; i++)
 {
 define_key_parser (keys[i], &(raw_keys[i]));
 }
-return (raw_lookup_key (keymap, raw_keys, nkeys, 0,
+return raw_lookup_key (keymap, raw_keys, nkeys, 0, accept_default);
-			  accept_default));
 }
 static Lisp_Object
 lookup_events (Lisp_Object event_head, int nmaps, Lisp_Object keymaps[],
 int accept_default)
 	}
 else if (!NILP (tem))
 	break;
 }
 UNGCPRO;
-return (tem);
+return tem;
 }
 DEFUN ("lookup-key", Flookup_key, 2, 3, 0, /*
 In keymap KEYMAP, look up key-sequence KEYS.  Return the definition.
 Nil is returned if KEYS is unbound.  See documentation of `define-key'
 {
 /* This function can GC */
 if (VECTORP (keys))
 {
 return lookup_keys (keymap,
-			  vector_length (XVECTOR (keys)),
+			  XVECTOR_LENGTH (keys),
-vector_data (XVECTOR (keys)),
+XVECTOR_DATA (keys),
 !NILP (accept_default));
 }
 else if (SYMBOLP (keys) || CHAR_OR_CHAR_INTP (keys) || CONSP (keys))
 {
 return lookup_keys (keymap, 1, &keys,
 for (i = 0; i < length; i++)
 	{
 Emchar n = string_char (XSTRING (keys), i);
 	  define_key_parser (make_char (n), &(raw_keys[i]));
 	}
-return (raw_lookup_key (keymap, raw_keys, length, 0,
+return raw_lookup_key (keymap, raw_keys, length, 0,
-!NILP (accept_default)));
+			     !NILP (accept_default));
 }
 }
 /* Given a key sequence, returns a list of keymaps to search for bindings.
 Does all manner of semi-hairy heuristics, like looking in the current
 if (EVENTP (keys))
 terminal = event_chain_tail (keys);
 else if (VECTORP (keys))
 {
-int len = vector_length (XVECTOR (keys));
+int len = XVECTOR_LENGTH (keys);
 if (len > 0)
-	terminal = vector_data (XVECTOR (keys))[len - 1];
+	terminal = XVECTOR_DATA (keys)[len - 1];
 }
 if (EVENTP (terminal))
 {
 CHECK_LIVE_EVENT (terminal);
 if (nmaps >= max_maps && max_maps > 0)
 maps[max_maps - 1] = Vcurrent_global_map;
 else
 maps[nmaps] = Vcurrent_global_map;
 UNGCPRO;
-return (nmaps + 1);
+return nmaps + 1;
 }
 }
 /* Returns a set of keymaps extracted from the extents at POS in
 BUFFER_OR_STRING.  The GLYPH arg, if specified, is one more extent
 	{
 	  Lisp_Object val = symbol_value_in_buffer (sym, buffer);
 	  if (!NILP (val) && !UNBOUNDP (val))
 	    {
 	      Lisp_Object map = get_keymap (XCDR (assoc), 0, 1);
-	      return (map);
+	      return map;
 	    }
 	}
 }
-return (Qnil);
+return Qnil;
 }
 static void
 get_relevant_minor_maps (Lisp_Object buffer, struct relevant_maps *closure)
 {
 {
 gubbish = (Lisp_Object *) alloca (nmaps * sizeof (Lisp_Object));
 nmaps = get_relevant_keymaps (event_or_keys, nmaps, gubbish);
 }
 UNGCPRO;
-return (Flist (nmaps, gubbish));
+return Flist (nmaps, gubbish);
 }
 DEFUN ("key-binding", Fkey_binding, 1, 2, 0, /*
 Return the binding for command KEYS in current keymaps.
 KEYS is a string, a vector of events, or a vector of key-description lists
 nmaps = get_relevant_keymaps (keys, countof (maps), maps);
 UNGCPRO;
 if (EVENTP (keys))           /* unadvertised "feature" for the future */
-return (lookup_events (keys, nmaps, maps,
+return lookup_events (keys, nmaps, maps, !NILP (accept_default));
-			   !NILP (accept_default)));
 for (i = 0; i < nmaps; i++)
 {
 Lisp_Object tem = Flookup_key (maps[i], keys,
 				     accept_default);
 if (INTP (tem))
 	{
 	  /* Too long in some local map means don't look at global map */
-	  return (Qnil);
+	  return Qnil;
 	}
 else if (!NILP (tem))
-	return (tem);
+	return tem;
 }
-return (Qnil);
+return Qnil;
 }
 static Lisp_Object
 process_event_binding_result (Lisp_Object result)
 {
 assert (EVENTP (event0));
 nmaps = get_relevant_keymaps (event0, countof (maps), maps);
 if (nmaps > countof (maps))
 nmaps = countof (maps);
-return (process_event_binding_result
+return process_event_binding_result (lookup_events (event0, nmaps, maps,
-	  (lookup_events (event0, nmaps, maps, accept_default)));
+						      accept_default));
 }
 /* Attempts to find a function key mapping corresponding to the
 event-sequence whose head is event0 (sequence is threaded through
 event_next).  The return value will be the same as for event_binding(). */
 DEFUN ("current-global-map", Fcurrent_global_map, 0, 0, 0, /*
 Return the current global keymap.
 */
 ())
 {
-return (Vcurrent_global_map);
+return Vcurrent_global_map;
 }
 /************************************************************************/
 /*                    Mapping over keymap elements                      */
 	}
 }
 /* all symbols (non-ASCIIs) come after characters (ASCIIs) */
 if (XTYPE (obj1) != XTYPE (obj2))
-return (SYMBOLP (obj2) ? 1 : -1);
+return SYMBOLP (obj2) ? 1 : -1;
 if (! bit1 && CHARP (obj1)) /* they're both ASCII */
 {
 int o1 = XCHAR (obj1);
 int o2 = XCHAR (obj2);
 if (o1 == o2 &&		/* If one started out as a symbol and the */
 	  sym1_p != sym2_p)	/* other didn't, the symbol comes last. */
-	return (sym2_p ? 1 : -1);
+	return sym2_p ? 1 : -1;
-return ((o1 < o2) ? 1 : -1); /* else just compare them */
+return o1 < o2 ? 1 : -1;	/* else just compare them */
 }
 /* else they're both symbols.  If they're both buckys, then order them. */
 if (bit1 && bit2)
-return ((bit1 < bit2) ? 1 : -1);
+return bit1 < bit2 ? 1 : -1;
 /* if only one is a bucky, then it comes later */
 if (bit1 || bit2)
-return (bit2 ? 1 : -1);
+return bit2 ? 1 : -1;
 /* otherwise, string-sort them. */
 {
 char *s1 = (char *) string_data (XSYMBOL (obj1)->name);
 char *s2 = (char *) string_data (XSYMBOL (obj2)->name);
-return (
 #ifdef I18N2
-	    (0 > strcoll (s1, s2))
+return 0 > strcoll (s1, s2) ? 1 : -1;
 #else
-	    (0 > strcmp (s1, s2))
+return 0 > strcmp  (s1, s2) ? 1 : -1;
 #endif
-	    ? 1 : -1);
 }
 }
 /* used by map_keymap() */
 {
 Lisp_Object thisseq = Fcar (Fcar (closure->tail));
 Lisp_Object cmd = get_keyelt (contents, 1);
 Lisp_Object vec;
 int j;
+int len;
 struct key_data key;
 key.keysym = keysym;
 key.modifiers = modifiers;
 if (NILP (cmd))
 	abort ();
 cmd = get_keymap (cmd, 0, 1);
 if (!KEYMAPP (cmd))
 	abort ();
-vec = make_vector (vector_length (XVECTOR (thisseq)) + 1, Qnil);
+vec = make_vector (XVECTOR_LENGTH (thisseq) + 1, Qnil);
-for (j = 0; j < vector_length (XVECTOR (thisseq)); j++)
+len = XVECTOR_LENGTH (thisseq);
-	vector_data (XVECTOR (vec)) [j] = vector_data (XVECTOR (thisseq)) [j];
+for (j = 0; j < len; j++)
-vector_data (XVECTOR (vec)) [j] = make_key_description (&key, 1);
+	XVECTOR_DATA (vec) [j] = XVECTOR_DATA (thisseq) [j];
+XVECTOR_DATA (vec) [j] = make_key_description (&key, 1);
 nconc2 (closure->tail, list1 (Fcons (vec, cmd)));
 }
 }
 accessible_keymaps_mapper_1 (XCAR (XCAR (submaps)),
 				   XCDR (XCAR (submaps)),
 				   0,
 				   closure);
 }
-return (Qnil);
+return Qnil;
 }
 DEFUN ("accessible-keymaps", Faccessible_keymaps, 1, 2, 0, /*
 Find all keymaps accessible via prefix characters from STARTMAP.
 NGCPRO1 (p);
 for (iii = 0; iii < len; iii++)
 	{
 	  struct key_data key;
 	  define_key_parser (Faref (prefix, make_int (iii)), &key);
-	  vector_data (XVECTOR (p))[iii] = make_key_description (&key, 1);
+	  XVECTOR_DATA (p)[iii] = make_key_description (&key, 1);
 	}
 NUNGCPRO;
 prefix = p;
 }
 traverse_keymaps (thismap, Qnil,
 accessible_keymaps_keymap_mapper, &c);
 }
 RETURN:
 UNGCPRO;
-return (accessible_keymaps);
+return accessible_keymaps;
 }
 /************************************************************************/
 for (i = 0; i < size; i++)
 	{
 	  Lisp_Object s2 = Fsingle_key_description
 	    (((STRINGP (keys))
 	      ? make_char (string_char (XSTRING (keys), i))
-	      : vector_data (XVECTOR (keys))[i]));
+	      : XVECTOR_DATA (keys)[i]));
 	  if (i == 0)
 	    string = s2;
 	  else
 	    {
 	      /* if (NILP (sep)) Lisp_Object sep = build_string (" ") */;
 	      string = concat2 (string, concat2 (Vsingle_space_string, s2));
 	    }
 	}
-return (string);
+return string;
 }
 return Fkey_description (wrong_type_argument (Qsequencep, keys));
 }
 DEFUN ("single-key-description", Fsingle_key_description, 1, 1, 0, /*
 			      XCONSOLE (Vselected_console), 0);
 	  format_event_object (buf, &event, 1);
 	}
 else
 	format_event_object (buf, XEVENT (key), 1);
-return (build_string (buf));
+return build_string (buf);
 }
 if (CONSP (key))
 {
 char buf[255];
 static Lisp_Object
 raw_keys_to_keys (struct key_data *keys, int count)
 {
 Lisp_Object result = make_vector (count, Qnil);
 while (count--)
-vector_data (XVECTOR (result)) [count] =
+XVECTOR_DATA (result) [count] = make_key_description (&(keys[count]), 1);
-make_key_description (&(keys[count]), 1);
+return result;
-return (result);
 }
 static void
 format_raw_keys (struct key_data *keys, int count, char *buf)
 	  /* OK, the key is for real */
 	  if (target_buffer)
 	    {
 	      if (!firstonly) abort ();
 	      format_raw_keys (so_far, keys_count + 1, target_buffer);
-	      return (make_int (1));
+	      return make_int (1);
 	    }
 	  else if (firstonly)
 	    return raw_keys_to_keys (so_far, keys_count + 1);
 	  else
 	    result = Fcons (raw_keys_to_keys (so_far, keys_count + 1),
 	c->modifiers_so_far = modifiers_so_far;
 	if (!firstonly)
 	  result = nconc2 (lower, result);
 	else if (!NILP (lower))
-	  return (lower);
+	  return lower;
 }
 }
-return (result);
+return result;
 }
 static Lisp_Object
 where_is_internal (Lisp_Object definition, Lisp_Object *maps, int nmaps,
 if (NILP (firstonly))
 result = Fnreverse (result);
 if (c.keys_so_far_malloced)
 xfree (c.keys_so_far);
-return (result);
+return result;
 }
 /************************************************************************/
 /*                         Describing keymaps                           */
 (map, all, shadow, prefix, mouse_only_p))
 {
 /* This function can GC */
 describe_map_tree (map, NILP (all), shadow, prefix,
 		     !NILP (mouse_only_p));
-return (Qnil);
+return Qnil;
 }
 /* Insert a desription of the key bindings in STARTMAP,
 followed by those of all maps reachable through STARTMAP.
 describe_map_mapper_shadow_search (Lisp_Object map, void *arg)
 {
 struct describe_map_shadow_closure *c = arg;
 if (EQ (map, c->self))
-return (Qzero);              /* Not shadowed; terminate search */
+return Qzero;		/* Not shadowed; terminate search */
-else if (!NILP (keymap_lookup_directly (map,
+if (!NILP (keymap_lookup_directly (map,
-c->raw_key->keysym,
+				     c->raw_key->keysym,
-c->raw_key->modifiers)))
+				     c->raw_key->modifiers)))
-return (Qt);
+return Qt;
 else
-return (Qnil);
+return Qnil;
 }
 static Lisp_Object
 keymap_lookup_inherited_mapper (Lisp_Object km, void *arg)
 {
 struct key_data *k = arg;
-return (keymap_lookup_directly (km, k->keysym, k->modifiers));
+return keymap_lookup_directly (km, k->keysym, k->modifiers);
 }
 static void
 describe_map_mapper (CONST struct key_data *key,
 obj1 = XCAR (obj1);
 obj2 = XCAR (obj2);
 bit1 = XINT (XCDR (obj1));
 bit2 = XINT (XCDR (obj2));
 if (bit1 != bit2)
-return ((bit1 < bit2) ? 1 : -1);
+return bit1 < bit2 ? 1 : -1;
 else
 return map_keymap_sort_predicate (obj1, obj2, pred);
 }
 /* Elide 2 or more consecutive numeric keysyms bound to the same thing,
 struct describe_map_closure *describe_map_closure = arg;
 describe_map_closure->self = keymap;
 map_keymap (XKEYMAP (keymap)->table,
 0, /* don't sort: we'll do it later */
 describe_map_mapper, describe_map_closure);
-return (Qnil);
+return Qnil;
 }
 static void
 describe_map (Lisp_Object keymap, Lisp_Object elt_prefix,

Mercurial > hg > xemacs-beta

comparison src/keymap.c @ 173:8eaf7971accc r20-3b13