Re: Function for deleting a key binding in a sparse keymap

[Lennart Borgman]

Richard M. Stallman wrote:

> I don't think that belongs in this node.  These things should be
> documented elsewhere.  What is needed here is a brief statement that
> key lookup is separate from key input, with mention of
> read-key-sequence, and an xref.
>  
I have made a much shorter version.

>    The keymap entry could also be a keymap.  In that case the next event
>    is looked up in that keymap.  
>
>    (@strong{But what happens if there is no hit there, I can not find any
>    documentation on this???})
>
> The question is not clear.  "No hit there"--where is "there"?
>  
It was just a silly misunderstanding of me. I have removed it.

>    @noindent
>    @strong{Remark 2:} Characters that are bound to
>    @code{self-insert-command} are translated according to
>    @code{translation-table-for-input} before insertion.
>
> How self-insert-command works is not part of this topic.
> It might be desirable to add this info somewhere else,
> but here it does not belong.
>  
I think a link to the place wher translation-table-for-input is 
explained would be good. BTW it would be easier to understand the 
purpose of this variable if it was named translation-table-for-insert. 
Is not that what it is?

I kept the remark in the code but think it should be replaced with that 
link.

>    @noindent
>    @strong{Remark 3:} You may find the function
>    @code{current-active-maps} useful when looking into this.
>
> Such vagueness is unhelpful.  Please say what the function does.
> Then add an xref to it.
I have rewritten it but I do not know how to make an xref to it.

I pretty much like the version I have attached now.

@subsection Finding the keymap and its entry to use

After translation of the input events (@pxref{Translating Input})
Emacs looks in the active keymaps.  As soon as a match is found
(@pxref{Key Lookup}) and the keymap entry is a function the search is
over.  However if the keymap entry is a variable symbol or a string
then Emacs replaces the input key sequences with the variable symbol
value or the string and restarts searching in the active keymaps.

Here is a pseudo-Lisp description of the order in which the active
keymaps are searched:

@lisp
(or (if overriding-terminal-local-map
        (@var{find-in} overriding-terminal-local-map)
      (if overriding-local-map
          (@var{find-in} overriding-local-map)
        (or (@var{find-in} (get-text-property (point) 'keymap))
            (@var{find-in-any} emulation-mode-map-alists)
            (@var{find-in-any} minor-mode-overriding-map-alist)
            (@var{find-in-any} minor-mode-map-alist)
            (@var{find-in} (get-text-property (point) 'local-map))
            (@var{find-in} (current-local-map)))))
    (@var{find-in} (current-global-map)))
@end lisp

@noindent
The @var{find-in} and @var{find-in-any} are pseudo functions that
searches in one keymap respectively an alist of keymaps.

@noindent
@strong{Remark 1:} The finally found function may be remapped
(@pxref{Remapping Commands}).

@noindent
@strong{Remark 2:} Characters that are bound to
@code{self-insert-command} are translated according to
@code{translation-table-for-input} before insertion.

@noindent
@strong{Remark 3:} @code{current-active-maps} returns a list of the
currently active keymaps at (point).