xemacs-beta: src/keymap.c comparison

comparison src/keymap.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	49a24b4fd526
children	8fc7fe29b841

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 }
 keymap->name = Qnil;
 return (result);
 }
-DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0 /*
+DEFUN ("make-keymap", Fmake_keymap, 0, 1, 0, /*
 Construct and return a new keymap object.
 All entries in it are nil, meaning \"command undefined\".
 Optional argument NAME specifies a name to assign to the keymap,
 as in `set-keymap-name'.  This name is only a debugging convenience;
 it is not used except when printing the keymap.
-*/ )
+*/
-(name)
+(name))
-Lisp_Object name;
 {
 Lisp_Object keymap = make_keymap (60);
 if (!NILP (name))
 Fset_keymap_name (keymap, name);
 return keymap;
 }
-DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap,
+DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, 0, 1, 0, /*
-0, 1, 0 /*
 Construct and return a new keymap object.
 All entries in it are nil, meaning \"command undefined\".  The only
 difference between this function and make-keymap is that this function
 returns a \"smaller\" keymap (one that is expected to contain fewer
 entries).  As keymaps dynamically resize, the distinction is not great.
 Optional argument NAME specifies a name to assign to the keymap,
 as in `set-keymap-name'.  This name is only a debugging convenience;
 it is not used except when printing the keymap.
-*/ )
+*/
-(name)
+(name))
-Lisp_Object name;
 {
 Lisp_Object keymap = make_keymap (8);
 if (!NILP (name))
 Fset_keymap_name (keymap, name);
 return keymap;
 }
-DEFUN ("keymap-parents", Fkeymap_parents, Skeymap_parents, 1, 1, 0 /*
+DEFUN ("keymap-parents", Fkeymap_parents, 1, 1, 0, /*
 Return the `parent' keymaps of the given keymap, or nil.
 The parents of a keymap are searched for keybindings when a key sequence
 isn't bound in this one.  `(current-global-map)' is the default parent
 of all keymaps.
-*/ )
+*/
-(keymap)
+(keymap))
-Lisp_Object keymap;
 {
 keymap = get_keymap (keymap, 1, 1);
 return (Fcopy_sequence (XKEYMAP (keymap)->parents));
 }
 traverse_keymaps_noop (Lisp_Object keymap, void *arg)
 {
 return (Qnil);
 }
-DEFUN ("set-keymap-parents", Fset_keymap_parents, Sset_keymap_parents, 2, 2, 0 /*
+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
 isn't bound in this one.  `(current-global-map)' is the default parent
 of all keymaps.
-*/ )
+*/
-(keymap, parents)
+(keymap, parents))
-Lisp_Object keymap, parents;
 {
 /* This function can GC */
 Lisp_Object k;
 struct gcpro gcpro1, gcpro2;
 XKEYMAP (keymap)->parents = Fcopy_sequence (parents);
 UNGCPRO;
 return (parents);
 }
-DEFUN ("set-keymap-name", Fset_keymap_name, Sset_keymap_name, 2, 2, 0 /*
+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
 when printing the keymap.
-*/ )
+*/
-(keymap, new_name)
+(keymap, new_name))
-Lisp_Object keymap, new_name;
 {
 keymap = get_keymap (keymap, 1, 1);
 XKEYMAP (keymap)->name = new_name;
 return (new_name);
 }
-DEFUN ("keymap-name", Fkeymap_name, Skeymap_name, 1, 1, 0 /*
+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
 when printing the keymap.
-*/ )
+*/
-(keymap)
+(keymap))
-Lisp_Object keymap;
 {
 keymap = get_keymap (keymap, 1, 1);
 return (XKEYMAP (keymap)->name);
 }
-DEFUN ("set-keymap-prompt", Fset_keymap_prompt, Sset_keymap_prompt, 2, 2, 0 /*
+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
 when reading a key-sequence to be looked-up in this keymap.
-*/ )
+*/
-(keymap, new_prompt)
+(keymap, new_prompt))
-Lisp_Object keymap, new_prompt;
 {
 keymap = get_keymap (keymap, 1, 1);
 if (!NILP (new_prompt))
 CHECK_STRING (new_prompt);
 {
 return (XKEYMAP (keymap)->prompt);
 }
-DEFUN ("keymap-prompt", Fkeymap_prompt, Skeymap_prompt, 1, 2, 0 /*
+DEFUN ("keymap-prompt", Fkeymap_prompt, 1, 2, 0, /*
 Return the `prompt' of the given keymap.
 If non-nil, the prompt is shown in the echo-area
 when reading a key-sequence to be looked-up in this keymap.
-*/ )
+*/
-(keymap, use_inherited)
+(keymap, use_inherited))
-Lisp_Object keymap, use_inherited;
 {
 /* This function can GC */
 Lisp_Object prompt;
 keymap = get_keymap (keymap, 1, 1);
 else
 return (traverse_keymaps (keymap, Qnil,
 			      keymap_prompt_mapper, 0));
 }
-DEFUN ("set-keymap-default-binding",
+DEFUN ("set-keymap-default-binding", Fset_keymap_default_binding, 2, 2, 0, /*
-Fset_keymap_default_binding, Sset_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
 no other binding for a key-sequence is found in the keymap.
 If a keymap has a non-nil default-binding, neither the keymap's
 parents nor the current global map are searched for key bindings.
-*/ )
+*/
-(keymap, command)
+(keymap, command))
-Lisp_Object keymap, command;
 {
 /* This function can GC */
 keymap = get_keymap (keymap, 1, 1);
 XKEYMAP (keymap)->default_binding = command;
 return (command);
 }
-DEFUN ("keymap-default-binding",
+DEFUN ("keymap-default-binding", Fkeymap_default_binding, 1, 1, 0, /*
-Fkeymap_default_binding, Skeymap_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
 is found in the keymap.
 If a keymap has a non-nil default-binding, neither the keymap's
 parents nor the current global map are searched for key bindings.
-*/ )
+*/
-(keymap)
+(keymap))
-Lisp_Object keymap;
 {
 /* This function can GC */
 keymap = get_keymap (keymap, 1, 1);
 return (XKEYMAP (keymap)->default_binding);
 }
-DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0 /*
+DEFUN ("keymapp", Fkeymapp, 1, 1, 0, /*
 Return t if ARG is a keymap object.
 The keymap may be autoloaded first if necessary.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 /* This function can GC */
 Lisp_Object tem = get_keymap (object, 0, 1);
 return ((KEYMAPP (tem)) ? Qt : Qnil);
 }
 		 XKEYMAP (keymap)->table,
 		 &copy_keymap_closure);
 return keymap;
 }
-DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0 /*
+DEFUN ("copy-keymap", Fcopy_keymap, 1, 1, 0, /*
 Return a copy of the keymap KEYMAP.
 The copy starts out with the same definitions of KEYMAP,
 but changing either the copy or KEYMAP does not affect the other.
 Any key definitions that are subkeymaps are recursively copied.
-*/ )
+*/
-(keymap)
+(keymap))
-Lisp_Object keymap;
 {
 /* This function can GC */
 keymap = get_keymap (keymap, 1, 1);
 return copy_keymap (keymap);
 }
 }
 UNGCPRO;
 return (fullness);
 }
-DEFUN ("keymap-fullness", Fkeymap_fullness, Skeymap_fullness, 1, 1, 0 /*
+DEFUN ("keymap-fullness", Fkeymap_fullness, 1, 1, 0, /*
 Return the number of bindings in the keymap.
-*/ )
+*/
-(keymap)
+(keymap))
-Lisp_Object keymap;
 {
 /* This function can GC */
 return (make_int (keymap_fullness
 		       (get_keymap (keymap, 1, 1))));
 }
 event.event.key.keysym = key->keysym;
 event.event.key.modifiers = key->modifiers;
 return event_matches_key_specifier_p (&event, Vmeta_prefix_char);
 }
-DEFUN ("event-matches-key-specifier-p",
+DEFUN ("event-matches-key-specifier-p", Fevent_matches_key_specifier_p, 2, 2, 0, /*
-Fevent_matches_key_specifier_p,
-Sevent_matches_key_specifier_p,
-2, 2, 0 /*
 Return non-nil if EVENT matches KEY-SPECIFIER.
 This can be useful, e.g., to determine if the user pressed `help-char' or
 `quit-char'.
-*/ )
+*/
-(event, key_specifier)
+(event, key_specifier))
-Lisp_Object event, key_specifier;
 {
 CHECK_LIVE_EVENT (event);
 return (event_matches_key_specifier_p (XEVENT (event), key_specifier)
 	  ? Qt : Qnil);
 }
 				   (Fsingle_key_description
 				    (Vmeta_prefix_char))));
 signal_simple_error (buf, mpc_binding);
 }
-DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0 /*
+DEFUN ("define-key", Fdefine_key, 3, 3, 0, /*
 Define key sequence KEYS, in KEYMAP, as DEF.
 KEYMAP is a keymap object.
 KEYS is the sequence of keystrokes to bind, described below.
 DEF is anything that can be a key's definition:
 nil (means key is undefined in this keymap);
 	(define-key global-map [(control x) tab] \'command-3)
 Of course, all of this applies only when running under a window system.  If
 you're talking to XEmacs through a TTY connection, you don't get any of
 these features.
-*/ )
+*/
-(keymap, keys, def)
+(keymap, keys, def))
-Lisp_Object keymap;
-Lisp_Object keys;
-Lisp_Object def;
 {
 /* This function can GC */
 int idx;
 int metized = 0;
 int size;
 }
 UNGCPRO;
 return (tem);
 }
-DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0 /*
+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'
 for valid key definitions and key-sequence specifications.
 A number is returned if KEYS is \"too long\"; that is, the leading
 characters fail to be a valid sequence of prefix characters in KEYMAP.
 The number is how many characters at the front of KEYS
 it takes to reach a non-prefix command.
-*/ )
+*/
-(keymap, keys, accept_default)
+(keymap, keys, accept_default))
-Lisp_Object keymap, keys, accept_default;
 {
 /* This function can GC */
 if (VECTORP (keys))
 {
 return lookup_keys (keymap,
 QUIT;
 }
 }
 /* #### Would map-current-keymaps be a better thing?? */
-DEFUN ("current-keymaps", Fcurrent_keymaps, Scurrent_keymaps, 0, 1, 0 /*
+DEFUN ("current-keymaps", Fcurrent_keymaps, 0, 1, 0, /*
 Return a list of the current keymaps that will be searched for bindings.
 This lists keymaps such as the current local map and the minor-mode maps,
 but does not list the parents of those keymaps.
 EVENT-OR-KEYS controls which keymaps will be listed.
 If EVENT-OR-KEYS is a mouse event (or a vector whose last element is a
 mouse event), the keymaps for that mouse event will be listed (see
 `key-binding').  Otherwise, the keymaps for key presses will be listed.
-*/ )
+*/
-(event_or_keys)
+(event_or_keys))
-Lisp_Object event_or_keys;
 {
 /* This function can GC */
 struct gcpro gcpro1;
 Lisp_Object maps[100];
 Lisp_Object *gubbish = maps;
 }
 UNGCPRO;
 return (Flist (nmaps, gubbish));
 }
-DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0 /*
+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
 as described in the documentation for the `define-key' function.
 The binding is probably a symbol with a function definition; see
 the documentation for `lookup-key' for more information.
 - any applicable minor-mode maps;
 - the current global map.
 Note that if `overriding-local-map' or `overriding-terminal-local-map'
 is non-nil, *only* those two maps and the current global map are searched.
-*/ )
+*/
-(keys, accept_default)
+(keys, accept_default))
-Lisp_Object keys, accept_default;
 {
 /* This function can GC */
 int i;
 Lisp_Object maps[100];
 int nmaps;
 /************************************************************************/
 /*               Setting/querying the global and local maps             */
 /************************************************************************/
-DEFUN ("use-global-map", Fuse_global_map, Suse_global_map, 1, 1, 0 /*
+DEFUN ("use-global-map", Fuse_global_map, 1, 1, 0, /*
 Select KEYMAP as the global keymap.
-*/ )
+*/
-(keymap)
+(keymap))
-Lisp_Object keymap;
 {
 /* This function can GC */
 keymap = get_keymap (keymap, 1, 1);
 Vcurrent_global_map = keymap;
 return Qnil;
 }
-DEFUN ("use-local-map", Fuse_local_map, Suse_local_map, 1, 2, 0 /*
+DEFUN ("use-local-map", Fuse_local_map, 1, 2, 0, /*
 Select KEYMAP as the local keymap in BUFFER.
 If KEYMAP is nil, that means no local keymap.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(keymap, buffer)
+(keymap, buffer))
-Lisp_Object keymap, buffer;
 {
 /* This function can GC */
 struct buffer *b = decode_buffer (buffer, 0);
 if (!NILP (keymap))
 keymap = get_keymap (keymap, 1, 1);
 b->keymap = keymap;
 return Qnil;
 }
-DEFUN ("current-local-map", Fcurrent_local_map, Scurrent_local_map, 0, 1, 0 /*
+DEFUN ("current-local-map", Fcurrent_local_map, 0, 1, 0, /*
 Return BUFFER's local keymap, or nil if it has none.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 struct buffer *b = decode_buffer (buffer, 0);
 return b->keymap;
 }
-DEFUN ("current-global-map", Fcurrent_global_map, Scurrent_global_map, 0, 0, 0 /*
+DEFUN ("current-global-map", Fcurrent_global_map, 0, 0, 0, /*
 Return the current global keymap.
-*/ )
+*/
-()
+())
 {
 return (Vcurrent_global_map);
 }
 elisp_maphash (map_keymap_unsorted_mapper, keymap_table,
 		     &map_keymap_unsorted_closure);
 }
 }
-DEFUN ("map-keymap", Fmap_keymap, Smap_keymap, 2, 3, 0 /*
+DEFUN ("map-keymap", Fmap_keymap, 2, 3, 0, /*
 Apply FUNCTION to each element of KEYMAP.
 FUNCTION will be called with two arguments: a key-description list, and
 the binding.  The order in which the elements of the keymap are passed to
 the function is unspecified.  If the function inserts new elements into
 the keymap, it may or may not be called with them later.  No element of
 If the optional third argument SORT-FIRST is non-nil, then the elements of
 the keymap will be passed to the mapper function in a canonical order.
 Otherwise, they will be passed in hash (that is, random) order, which is
 faster.
-*/ )
+*/
-(function, keymap, sort_first)
+(function, keymap, sort_first))
-Lisp_Object function, keymap, sort_first;
 {
 /* This function can GC */
 struct gcpro gcpro1, gcpro2;
 /* tolerate obviously transposed args */
 }
 return (Qnil);
 }
-DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
+DEFUN ("accessible-keymaps", Faccessible_keymaps, 1, 2, 0, /*
-1, 2, 0 /*
 Find all keymaps accessible via prefix characters from STARTMAP.
 Returns a list of elements of the form (KEYS . MAP), where the sequence
 KEYS starting from STARTMAP gets you to MAP.  These elements are ordered
 so that the KEYS increase in length.  The first element is ([] . STARTMAP).
 An optional argument PREFIX, if non-nil, should be a key sequence;
 then the value includes only maps for prefixes that start with PREFIX.
-*/ )
+*/
-(startmap, prefix)
+(startmap, prefix))
-Lisp_Object startmap, prefix;
 {
 /* This function can GC */
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 Lisp_Object accessible_keymaps = Qnil;
 struct accessible_keymaps_closure c;
 /************************************************************************/
 /*              Pretty descriptions of key sequences                    */
 /************************************************************************/
-DEFUN ("key-description", Fkey_description, Skey_description, 1, 1, 0 /*
+DEFUN ("key-description", Fkey_description, 1, 1, 0, /*
 Return a pretty description of key-sequence KEYS.
 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"
 spaces are put between sequence elements, etc.
-*/ )
+*/
-(keys)
+(keys))
-Lisp_Object keys;
 {
 if (INTP (keys) || CONSP (keys) || SYMBOLP (keys) || EVENTP (keys))
 {
 return Fsingle_key_description (keys);
 }
 return (string);
 }
 return Fkey_description (wrong_type_argument (Qsequencep, keys));
 }
-DEFUN ("single-key-description", Fsingle_key_description,
+DEFUN ("single-key-description", Fsingle_key_description, 1, 1, 0, /*
-Ssingle_key_description, 1, 1, 0 /*
 Return a pretty description of command character KEY.
 Control characters turn into C-whatever, etc.
 This differs from `text-char-description' in that it returns a description
 of a key read from the user rather than a character from a buffer.
-*/ )
+*/
-(key)
+(key))
-Lisp_Object key;
 {
 if (SYMBOLP (key))
 key = Fcons (key, Qnil); /* sleaze sleaze */
 if (EVENTP (key) || CHARP (key))
 }
 return Fsingle_key_description
 (wrong_type_argument (intern ("char-or-event-p"), key));
 }
-DEFUN ("text-char-description", Ftext_char_description, Stext_char_description,
+DEFUN ("text-char-description", Ftext_char_description, 1, 1, 0, /*
-1, 1, 0 /*
 Return a pretty description of file-character CHR.
 Unprintable characters turn into \"^char\" or \\NNN, depending on the value
 of the `ctl-arrow' variable.
 This differs from `single-key-description' in that it returns a description
 of a character from a buffer rather than a key read from the user.
-*/ )
+*/
-(chr)
+(chr))
-Lisp_Object chr;
 {
 Bufbyte buf[200];
 Bufbyte *p;
 unsigned int c;
 Lisp_Object ctl_arrow = current_buffer->ctl_arrow;
 static Lisp_Object
 where_is_internal (Lisp_Object definition, Lisp_Object *maps, int nmaps,
 Lisp_Object firstonly, char *target_buffer);
-DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0 /*
+DEFUN ("where-is-internal", Fwhere_is_internal, 1, 5, 0, /*
 Return list of keys that invoke DEFINITION in KEYMAPS.
 KEYMAPS can be either a keymap (meaning search in that keymap and the
 current global keymap) or a list of keymaps (meaning search in exactly
 those keymaps and no others).  If KEYMAPS is nil, search in the currently
 applicable maps for EVENT-OR-KEYS (this is equivalent to specifying
 sequences.
 If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
 to other keymaps or slots.  This makes it possible to search for an
 indirect definition itself.
-*/ )
+*/
-(definition, keymaps, firstonly, noindirect, event_or_keys)
+(definition, keymaps, firstonly, noindirect, event_or_keys))
-Lisp_Object definition, keymaps, firstonly, noindirect, event_or_keys;
 {
 /* This function can GC */
 Lisp_Object maps[100];
 Lisp_Object *gubbish = maps;
 int nmaps;
 /************************************************************************/
 /*                         Describing keymaps                           */
 /************************************************************************/
-DEFUN ("describe-bindings-internal",
+DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal, 1, 5, 0, /*
-Fdescribe_bindings_internal, Sdescribe_bindings_internal, 1, 5, 0 /*
 Insert a list of all defined keys and their definitions in MAP.
 Optional second argument ALL says whether to include even \"uninteresting\"
 definitions (ie symbols with a non-nil `suppress-keymap' property.
 Third argument SHADOW is a list of keymaps whose bindings shadow those
 of map; if a binding is present in any shadowing map, it is not printed.
 Fourth argument PREFIX, if non-nil, should be a key sequence;
 only bindings which start with that key sequence will be printed.
 Fifth argument MOUSE-ONLY-P says to only print bindings for mouse clicks.
-*/ )
+*/
-(map, all, shadow, prefix, mouse_only_p)
+(map, all, shadow, prefix, mouse_only_p))
-Lisp_Object 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);
 defsymbol (&Qsuppress_keymap, "suppress-keymap");
 defsymbol (&Qmodeline_map, "modeline-map");
 defsymbol (&Qtoolbar_map, "toolbar-map");
-defsubr (&Skeymap_parents);
+DEFSUBR (Fkeymap_parents);
-defsubr (&Sset_keymap_parents);
+DEFSUBR (Fset_keymap_parents);
-defsubr (&Skeymap_name);
+DEFSUBR (Fkeymap_name);
-defsubr (&Sset_keymap_name);
+DEFSUBR (Fset_keymap_name);
-defsubr (&Skeymap_prompt);
+DEFSUBR (Fkeymap_prompt);
-defsubr (&Sset_keymap_prompt);
+DEFSUBR (Fset_keymap_prompt);
-defsubr (&Skeymap_default_binding);
+DEFSUBR (Fkeymap_default_binding);
-defsubr (&Sset_keymap_default_binding);
+DEFSUBR (Fset_keymap_default_binding);
-defsubr (&Skeymapp);
+DEFSUBR (Fkeymapp);
-defsubr (&Smake_keymap);
+DEFSUBR (Fmake_keymap);
-defsubr (&Smake_sparse_keymap);
+DEFSUBR (Fmake_sparse_keymap);
-defsubr (&Scopy_keymap);
+DEFSUBR (Fcopy_keymap);
-defsubr (&Skeymap_fullness);
+DEFSUBR (Fkeymap_fullness);
-defsubr (&Smap_keymap);
+DEFSUBR (Fmap_keymap);
-defsubr (&Sevent_matches_key_specifier_p);
+DEFSUBR (Fevent_matches_key_specifier_p);
-defsubr (&Sdefine_key);
+DEFSUBR (Fdefine_key);
-defsubr (&Slookup_key);
+DEFSUBR (Flookup_key);
-defsubr (&Skey_binding);
+DEFSUBR (Fkey_binding);
-defsubr (&Suse_global_map);
+DEFSUBR (Fuse_global_map);
-defsubr (&Suse_local_map);
+DEFSUBR (Fuse_local_map);
-defsubr (&Scurrent_local_map);
+DEFSUBR (Fcurrent_local_map);
-defsubr (&Scurrent_global_map);
+DEFSUBR (Fcurrent_global_map);
-defsubr (&Scurrent_keymaps);
+DEFSUBR (Fcurrent_keymaps);
-defsubr (&Saccessible_keymaps);
+DEFSUBR (Faccessible_keymaps);
-defsubr (&Skey_description);
+DEFSUBR (Fkey_description);
-defsubr (&Ssingle_key_description);
+DEFSUBR (Fsingle_key_description);
-defsubr (&Swhere_is_internal);
+DEFSUBR (Fwhere_is_internal);
-defsubr (&Sdescribe_bindings_internal);
+DEFSUBR (Fdescribe_bindings_internal);
-defsubr (&Stext_char_description);
+DEFSUBR (Ftext_char_description);
 defsymbol (&Qcontrol, "control");
 defsymbol (&Qctrl, "ctrl");
 defsymbol (&Qmeta, "meta");
 defsymbol (&Qsuper, "super");

Mercurial > hg > xemacs-beta

comparison src/keymap.c @ 20:859a2309aef8 r19-15b93