The first thing the command loop must do is read a key sequence, which
is a sequence of events that translates into a command. It does this by
calling the function
read-key-sequence. Your Lisp code can also
call this function (see Key Sequence Input). Lisp programs can also
do input at a lower level with
read-event (see Reading One Event) or discard pending input with
(see Event Input Misc).
The key sequence is translated into a command through the currently
active keymaps. See Key Lookup, for information on how this is done.
The result should be a keyboard macro or an interactively callable
function. If the key is M-x, then it reads the name of another
command, which it then calls. This is done by the command
execute-extended-command (see Interactive Call).
Prior to executing the command, Emacs runs
create an undo boundary. See Maintaining Undo.
To execute a command, Emacs first reads its arguments by calling
command-execute (see Interactive Call). For commands
written in Lisp, the
interactive specification says how to read
the arguments. This may use the prefix argument (see Prefix Command Arguments) or may read with prompting in the minibuffer
(see Minibuffers). For example, the command
interactive specification which says to read a file name
using the minibuffer. The function body of
find-file does not
use the minibuffer, so if you call
find-file as a function from
Lisp code, you must supply the file name string as an ordinary Lisp
If the command is a string or vector (i.e., a keyboard macro) then
execute-kbd-macro is used to execute it. You can call this
function yourself (see Keyboard Macros).
To terminate the execution of a running command, type C-g. This character causes quitting (see Quitting).
The editor command loop runs this normal hook before each command. At that time,
this-commandcontains the command that is about to run, and
last-commanddescribes the previous command. See Command Loop Info.
The editor command loop runs this normal hook after each command (including commands terminated prematurely by quitting or by errors), and also when the command loop is first entered. At that time,
this-commandrefers to the command that just ran, and
last-commandrefers to the command before that.
Quitting is suppressed while running
post-command-hook. If an error happens while executing one of
these hooks, it terminates execution of the hook, and clears the hook
nil so as to prevent an infinite loop of errors.
A request coming into the Emacs server (see Emacs Server) runs these two hooks just as a keyboard command does.blog comments powered by Disqus