Command Loop
************

When you run XEmacs, it enters the editor command loop almost immediately.  This loop reads events, executes their definitions, and displays the results.  In this chapter, we describe how these things are done, and the subroutines that allow Lisp programs to do them.

Command Loop Overview
=====================

The command loop in XEmacs is a standard event loop, reading events one at a time with next-event and handling them with dispatch-event.  An event is typically a single user action, such as a keypress, mouse movement, or menu selection; but they can also be notifications from the window system, informing XEmacs that (for example) part of its window was just uncovered and needs to be redrawn. See Events.  Pending events are held in a first-in, first-out list called the event queue: events are read from the head of the list, and newly arriving events are added to the tail.  In this way, events are always processed in the order in which they arrive.

dispatch-event does most of the work of handling user actions. The first thing it must do is put the events together into a key sequence, which is a sequence of events that translates into a command. It does this by consulting the active keymaps, which specify what the valid key sequences are and how to translate them into commands. See Key Lookup, for information on how this is done.  The result of the translation 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).

To execute a command requires first reading the arguments for it. This is done 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 find-file has an interactive specification which says to read a file name using the minibuffer.  The command's function body does not use the minibuffer; if you call this command from Lisp code as a function, you must supply the file name string as an ordinary Lisp function argument.

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).

 -- Variable: pre-command-hook
     The editor command loop runs this normal hook before each command.  At that time, this-command contains the command that is about to run, and last-command describes the previous command. See Hooks.

 -- Variable: post-command-hook
     The editor command loop runs this normal hook after each command.  (In FSF Emacs, it is also run when the command loop is entered, or reentered after an error or quit.)  At that time, this-command describes the command that just ran, and last-command describes the command before that.  See Hooks.

Quitting is suppressed while running pre-command-hook and post-command-hook.  If an error happens while executing one of these hooks, it terminates execution of the hook, but that is all it does.

Defining Commands
=================

A Lisp function becomes a command when its body contains, at top level, a form that calls the special form interactive.  This form does nothing when actually executed, but its presence serves as a flag to indicate that interactive calling is permitted.  Its argument controls the reading of arguments for an interactive call.

Using interactive
-----------------

This section describes how to write the interactive form that makes a Lisp function an interactively-callable command.

 -- Special Form: interactive arg-descriptor
     This special form declares that the function in which it appears is a command, and that it may therefore be called interactively (via M-x or by entering a key sequence bound to it).  The argument ARG-DESCRIPTOR declares how to compute the arguments to the command when the command is called interactively.

     A command may be called from Lisp programs like any other function, but then the caller supplies the arguments and ARG-DESCRIPTOR has no effect.

     The interactive form has its effect because the command loop (actually, its subroutine call-interactively) scans through the function definition looking for it, before calling the function.  Once the function is called, all its body forms including the interactive form are executed, but at this time interactive simply returns nil without even evaluating its argument.

There are three possibilities for the argument ARG-DESCRIPTOR:

  * It may be omitted or nil; then the command is called with no arguments.  This leads quickly to an error if the command requires one or more arguments.

  * It may be a Lisp expression that is not a string; then it should be a form that is evaluated to get a list of arguments to pass to the command.

     If this expression reads keyboard input (this includes using the minibuffer), keep in mind that the integer value of point or the mark before reading input may be incorrect after reading input.  This is because the current buffer may be receiving subprocess output; if subprocess output arrives while the command is waiting for input, it could relocate point and the mark.

     Here's an example of what not to do:

          (interactive
           (list (region-beginning) (region-end)
                 (read-string "Foo: " nil 'my-history)))

     Here's how to avoid the problem, by examining point and the mark only after reading the keyboard input:

          (interactive
           (let ((string (read-string "Foo: " nil 'my-history)))
             (list (region-beginning) (region-end) string)))

  * It may be a string; then its contents should consist of a code character followed by a prompt (which some code characters use and some ignore). The prompt ends either with the end of the string or with a newline. Here is a simple example:

          (interactive "bFrobnicate buffer: ")

     The code letter b says to read the name of an existing buffer, with completion.  The buffer name is the sole argument passed to the command.  The rest of the string is a prompt.

     If there is a newline character in the string, it terminates the prompt. If the string does not end there, then the rest of the string should contain another code character and prompt, specifying another argument. You can specify any number of arguments in this way.

     The prompt string can use % to include previous argument values (starting with the first argument) in the prompt.  This is done using format (see Formatting Strings).  For example, here is how you could read the name of an existing buffer followed by a new name to give to that buffer:

          (interactive "bBuffer to rename: \nsRename buffer %s to: ")

     If the first character in the string is *, then an error is signaled if the buffer is read-only.

     If the first character in the string is @, and if the key sequence used to invoke the command includes any mouse events, then the window associated with the first of those events is selected before the command is run.

     If the first character in the string is _, then this command will not cause the region to be deactivated when it completes; that is, zmacs-region-stays will be set to t when the command exits successfully.

     You can use *, @, and _ together; the order does not matter.  Actual reading of arguments is controlled by the rest of the prompt string (starting with the first character that is not *, @, or _).

 -- Function: function-interactive function
     This function retrieves the interactive specification of FUNCTION, which may be any funcallable object.  The specification will be returned as the list of the symbol interactive and the specs.  If FUNCTION is not interactive, nil will be returned.

Code Characters for interactive
-------------------------------

The code character descriptions below contain a number of key words, defined here as follows:

Completion
     Provide completion.  TAB, SPC, and RET perform name completion because the argument is read using completing-read (see Completion).  ? displays a list of possible completions.

Existing
     Require the name of an existing object.  An invalid name is not accepted; the commands to exit the minibuffer do not exit if the current input is not valid.

Default
     A default value of some sort is used if the user enters no text in the minibuffer.  The default depends on the code character.

No I/O
     This code letter computes an argument without reading any input. Therefore, it does not use a prompt string, and any prompt string you supply is ignored.

     Even though the code letter doesn't use a prompt string, you must follow it with a newline if it is not the last code character in the string.

Prompt
     A prompt immediately follows the code character.  The prompt ends either with the end of the string or with a newline.

Special
     This code character is meaningful only at the beginning of the interactive string, and it does not look for a prompt or a newline. It is a single, isolated character.

Here are the code character descriptions for use with interactive:

*
     Signal an error if the current buffer is read-only.  Special.

@
     Select the window mentioned in the first mouse event in the key sequence that invoked this command.  Special.

_
     Do not cause the region to be deactivated when this command completes. Special.

a
     A function name (i.e., a symbol satisfying fboundp).  Existing, Completion, Prompt.

b
     The name of an existing buffer.  By default, uses the name of the current buffer (see Buffers).  Existing, Completion, Default, Prompt.

B
     A buffer name.  The buffer need not exist.  By default, uses the name of a recently used buffer other than the current buffer.  Completion, Default, Prompt.

c
     A character.  The cursor does not move into the echo area.  Prompt.

C
     A command name (i.e., a symbol satisfying commandp).  Existing, Completion, Prompt.

d
     The position of point, as an integer (see Point).  No I/O.

D
     A directory name.  The default is the current default directory of the current buffer, default-directory (see System Environment). Existing, Completion, Default, Prompt.

e
     The last mouse-button or misc-user event in the key sequence that invoked the command.  No I/O.

     You can use e more than once in a single command's interactive specification.  If the key sequence that invoked the command has N mouse-button or misc-user events, the Nth e provides the Nth such event.

f
     A file name of an existing file (see File Names).  The default directory is default-directory.  Existing, Completion, Default, Prompt.

F
     A file name.  The file need not exist.  Completion, Default, Prompt.

k
     A key sequence (see Keymap Terminology).  This keeps reading events until a command (or undefined command) is found in the current key maps.  The key sequence argument is represented as a vector of events. The cursor does not move into the echo area.  Prompt.

     This kind of input is used by commands such as describe-key and global-set-key.

K
     A key sequence, whose definition you intend to change.  This works like k, except that it suppresses, for the last input event in the key sequence, the conversions that are normally used (when necessary) to convert an undefined key into a defined one.

m
     The position of the mark, as an integer.  No I/O.

n
     A number read with the minibuffer.  If the input is not a number, the user is asked to try again.  The prefix argument, if any, is not used. Prompt.

N
     The raw prefix argument.  If the prefix argument is nil, then read a number as with n.  Requires a number.  See Prefix Command Arguments.  Prompt.

p
     The numeric prefix argument.  (Note that this p is lower case.) No I/O.

P
     The raw prefix argument.  (Note that this P is upper case.)  No I/O.

r
     Point and the mark, as two numeric arguments, smallest first.  This is the only code letter that specifies two successive arguments rather than one.  No I/O.

s
     Arbitrary text, read in the minibuffer and returned as a string (see Text from Minibuffer).  Terminate the input with either LFD or RET.  (C-q may be used to include either of these characters in the input.)  Prompt.

S
     An interned symbol whose name is read in the minibuffer.  Any whitespace character terminates the input.  (Use C-q to include whitespace in the string.)  Other characters that normally terminate a symbol (e.g., parentheses and brackets) do not do so here.  Prompt.

v
     A variable declared to be a user option (i.e., satisfying the predicate user-variable-p).  See High-Level Completion.  Existing, Completion, Prompt.

x
     A Lisp object, specified with its read syntax, terminated with a LFD or RET.  The object is not evaluated.  See Object from Minibuffer.  Prompt.

X
     A Lisp form is read as with x, but then evaluated so that its value becomes the argument for the command.  Prompt.

Examples of Using interactive
-----------------------------

Here are some examples of interactive:

     (defun foo1 ()              ; foo1 takes no arguments,
         (interactive)           ;   just moves forward two words.
         (forward-word 2))
          => foo1

     (defun foo2 (n)             ; foo2 takes one argument,
         (interactive "p")       ;   which is the numeric prefix.
         (forward-word (* 2 n)))
          => foo2

     (defun foo3 (n)             ; foo3 takes one argument,
         (interactive "nCount:") ;   which is read with the Minibuffer.
         (forward-word (* 2 n)))
          => foo3

     (defun three-b (b1 b2 b3)
       "Select three existing buffers.
     Put them into three windows, selecting the last one."

         (interactive "bBuffer1:\nbBuffer2:\nbBuffer3:")
         (delete-other-windows)
         (split-window (selected-window) 8)
         (switch-to-buffer b1)
         (other-window 1)
         (split-window (selected-window) 8)
         (switch-to-buffer b2)
         (other-window 1)
         (switch-to-buffer b3))
          => three-b

     (three-b "*scratch*" "declarations.texi" "*mail*")
          => nil

Interactive Call
================

After the command loop has translated a key sequence into a definition, it invokes that definition using the function command-execute.  If the definition is a function that is a command, command-execute calls call-interactively, which reads the arguments and calls the command.  You can also call these functions yourself.

 -- Function: commandp object
     Returns t if OBJECT is suitable for calling interactively; that is, if OBJECT is a command.  Otherwise, returns nil.

     The interactively callable objects include strings and vectors (treated as keyboard macros), lambda expressions that contain a top-level call to interactive, compiled-function objects made from such lambda expressions, autoload objects that are declared as interactive (non-nil fourth argument to autoload), and some of the primitive functions.

     A symbol is commandp if its function definition is commandp.

     Keys and keymaps are not commands.  Rather, they are used to look up commands (see Keymaps).

     See documentation in Accessing Documentation, for a realistic example of using commandp.

 -- Function: call-interactively command &optional record-flag
     This function calls the interactively callable function COMMAND, reading arguments according to its interactive calling specifications. An error is signaled if COMMAND is not a function or if it cannot be called interactively (i.e., is not a command).  Note that keyboard macros (strings and vectors) are not accepted, even though they are considered commands, because they are not functions.

     If RECORD-FLAG is the symbol lambda, the interactive calling arguments for command are read and returned as a list, but the function is not called on them.

     If RECORD-FLAG is t, then this command and its arguments are unconditionally added to the list command-history. Otherwise, the command is added only if it uses the minibuffer to read an argument.  See Command History.

 -- Function: command-execute command &optional record-flag
     This function executes COMMAND as an editing command.  The argument COMMAND must satisfy the commandp predicate; i.e., it must be an interactively callable function or a keyboard macro.

     A string or vector as COMMAND is executed with execute-kbd-macro.  A function is passed to call-interactively, along with the optional RECORD-FLAG.

     A symbol is handled by using its function definition in its place.  A symbol with an autoload definition counts as a command if it was declared to stand for an interactively callable function.  Such a definition is handled by loading the specified library and then rechecking the definition of the symbol.

 -- Command: execute-extended-command prefix-argument
     This function reads a command name from the minibuffer using completing-read (see Completion).  Then it uses command-execute to call the specified command.  Whatever that command returns becomes the value of execute-extended-command.

     If the command asks for a prefix argument, it receives the value PREFIX-ARGUMENT.  If execute-extended-command is called interactively, the current raw prefix argument is used for PREFIX-ARGUMENT, and thus passed on to whatever command is run.

     execute-extended-command is the normal definition of M-x, so it uses the string M-x  as a prompt.  (It would be better to take the prompt from the events used to invoke execute-extended-command, but that is painful to implement.)  A description of the value of the prefix argument, if any, also becomes part of the prompt.

          (execute-extended-command 1)
          ---------- Buffer: Minibuffer ----------
          1 M-x forward-word RET
          ---------- Buffer: Minibuffer ----------
               => t

 -- Function: interactive-p
     This function returns t if the containing function (the one that called interactive-p) was called interactively, with the function call-interactively.  (It makes no difference whether call-interactively was called from Lisp or directly from the editor command loop.)  If the containing function was called by Lisp evaluation (or with apply or funcall), then it was not called interactively.

     The most common use of interactive-p is for deciding whether to print an informative message.  As a special exception, interactive-p returns nil whenever a keyboard macro is being run.  This is to suppress the informative messages and speed execution of the macro.

     For example:

          (defun foo ()
            (interactive)
            (and (interactive-p)
                 (message "foo")))
               => foo

          (defun bar ()
            (interactive)
            (setq foobar (list (foo) (interactive-p))))
               => bar

          ;; Type M-x foo.
               -| foo

          ;; Type M-x bar.
          ;; This does not print anything.

          foobar
               => (nil t)

Information from the Command Loop
=================================

The editor command loop sets several Lisp variables to keep status records for itself and for commands that are run.

 -- Variable: last-command
     This variable records the name of the previous command executed by the command loop (the one before the current command).  Normally the value is a symbol with a function definition, but this is not guaranteed.

     The value is copied from this-command when a command returns to the command loop, except when the command specifies a prefix argument for the following command.

 -- Variable: this-command
     This variable records the name of the command now being executed by the editor command loop.  Like last-command, it is normally a symbol with a function definition.

     The command loop sets this variable just before running a command, and copies its value into last-command when the command finishes (unless the command specifies a prefix argument for the following command).

     Some commands set this variable during their execution, as a flag for whatever command runs next.  In particular, the functions for killing text set this-command to kill-region so that any kill commands immediately following will know to append the killed text to the previous kill.

If you do not want a particular command to be recognized as the previous command in the case where it got an error, you must code that command to prevent this.  One way is to set this-command to t at the beginning of the command, and set this-command back to its proper value at the end, like this:

     (defun foo (args...)
       (interactive ...)
       (let ((old-this-command this-command))
         (setq this-command t)
         ...do the work...
         (setq this-command old-this-command)))

 -- Function: this-command-keys
     This function returns a vector containing the key and mouse events that invoked the present command, plus any previous commands that generated the prefix argument for this command. (Note: this is not the same as in FSF Emacs, which can return a string.)  See Events.

     This function copies the vector and the events; it is safe to keep and modify them.

          (this-command-keys)
          ;; Now use C-u C-x C-e to evaluate that.
               => [#<keypress-event control-U> #<keypress-event control-X> #<keypress-event control-E>]

 -- Variable: last-command-event
     This variable is set to the last input event that was read by the command loop as part of a command.  The principal use of this variable is in self-insert-command, which uses it to decide which character to insert.

     This variable is off limits: you may not set its value or modify the event that is its value, as it is destructively modified by read-key-sequence.  If you want to keep a pointer to this value, you must use copy-event.

     Note that this variable is an alias for last-command-char in FSF Emacs.

          last-command-event
          ;; Now type C-u C-x C-e.
               => #<keypress-event control-E>

 -- Variable: last-command-char

     If the value of last-command-event is a keyboard event, then this is the nearest character equivalent to it (or nil if there is no character equivalent).  last-command-char is the character that self-insert-command will insert in the buffer.  Remember that there is not a one-to-one mapping between keyboard events and XEmacs characters: many keyboard events have no corresponding character, and when the Mule feature is available, most characters can not be input on standard keyboards, except possibly with help from an input method. So writing code that examines this variable to determine what key has been typed is bad practice, unless you are certain that it will be one of a small set of characters.

     This variable exists for compatibility with Emacs version 18.

          last-command-char
          ;; Now use C-u C-x C-e to evaluate that.
               => ?\^E

 -- Variable: current-mouse-event
     This variable holds the mouse-button event which invoked this command, or nil.  This is what (interactive "e") returns.

 -- Variable: echo-keystrokes
     This variable determines how much time should elapse before command characters echo.  Its value must be an integer, which specifies the number of seconds to wait before echoing.  If the user types a prefix key (say C-x) and then delays this many seconds before continuing, the key C-x is echoed in the echo area.  Any subsequent characters in the same command will be echoed as well.

     If the value is zero, then command input is not echoed.

Events
======

The XEmacs command loop reads a sequence of events that represent keyboard or mouse activity.  Unlike in Emacs 18 and in FSF Emacs, events are a primitive Lisp type that must be manipulated using their own accessor and settor primitives.  This section describes the representation and meaning of input events in detail.

A key sequence that starts with a mouse event is read using the keymaps of the buffer in the window that the mouse was in, not the current buffer.  This does not imply that clicking in a window selects that window or its buffer---that is entirely under the control of the command binding of the key sequence.

For information about how exactly the XEmacs command loop works, see Reading Input.

 -- Function: eventp object
     This function returns non-nil if EVENT is an input event.

Event Types
-----------

Events represent keyboard or mouse activity or status changes of various sorts, such as process input being available or a timeout being triggered. The different event types are as follows:

key-press event
     A key was pressed.  Note that modifier keys such as ``control'', ``shift'', and ``alt'' do not generate events; instead, they are tracked internally by XEmacs, and non-modifier key presses generate events that specify both the key pressed and the modifiers that were held down at the time.

button-press event
button-release event
     A button was pressed or released.  Along with the button that was pressed or released, button events specify the modifier keys that were held down at the time and the position of the pointer at the time.

motion event
     The pointer was moved.  Along with the position of the pointer, these events also specify the modifier keys that were held down at the time.

misc-user event
     A menu item was selected, the scrollbar was used, or a drag or a drop occured.

process event
     Input is available on a process.

timeout event
     A timeout has triggered.

magic event
     Some window-system-specific action (such as a frame being resized or a portion of a frame needing to be redrawn) has occurred.  The contents of this event are not accessible at the E-Lisp level, but dispatch-event knows what to do with an event of this type.

eval event
     This is a special kind of event specifying that a particular function needs to be called when this event is dispatched.  An event of this type is sometimes placed in the event queue when a magic event is processed. This kind of event should generally just be passed off to dispatch-event.  See Dispatching an Event.

Contents of the Different Types of Events
-----------------------------------------

Every event, no matter what type it is, contains a timestamp (which is typically an offset in milliseconds from when the X server was started) indicating when the event occurred.  In addition, many events contain a channel, which specifies which frame the event occurred on, and/or a value indicating which modifier keys (shift, control, etc.) were held down at the time of the event.

The contents of each event are as follows:

key-press event

     channel

     timestamp

     key
          Which key was pressed.  This is an integer (in the printing ASCII range: >32 and <127) or a symbol such as left or right. Note that many physical keys are actually treated as two separate keys, depending on whether the shift key is pressed; for example, the ``a'' key is treated as either ``a'' or ``A'' depending on the state of the shift key, and the ``1'' key is similarly treated as either ``1'' or ``!'' on most keyboards.  In such cases, the shift key does not show up in the modifier list.  For other keys, such as backspace, the shift key shows up as a regular modifier.

     modifiers
          Which modifier keys were pressed.  As mentioned above, the shift key is not treated as a modifier for many keys and will not show up in this list in such cases.

button-press event
button-release event

     channel

     timestamp

     button
          What button went down or up.  Buttons are numbered starting at 1.

     modifiers
          Which modifier keys were pressed.  The special business mentioned above for the shift key does not apply to mouse events.

     x
     y
          The position of the pointer (in pixels) at the time of the event.

pointer-motion event

     channel

     timestamp

     x
     y
          The position of the pointer (in pixels) after it moved.

     modifiers
          Which modifier keys were pressed.  The special business mentioned above for the shift key does not apply to mouse events.

misc-user event

     timestamp

     function
          The E-Lisp function to call for this event.  This is normally either eval or call-interactively.

     object
          The object to pass to the function.  This is normally the callback that was specified in the menu description.

     button
          What button went down or up.  Buttons are numbered starting at 1.

     modifiers
          Which modifier keys were pressed.  The special business mentioned above for the shift key does not apply to mouse events.

     x
     y
          The position of the pointer (in pixels) at the time of the event.

process_event

     timestamp

     process
          The Emacs ``process'' object in question.

timeout event

     timestamp

     function
          The E-Lisp function to call for this timeout.  It is called with one argument, the event.

     object
          Some Lisp object associated with this timeout, to make it easier to tell them apart.  The function and object for this event were specified when the timeout was set.

magic event

     timestamp

     (The rest of the information in this event is not user-accessible.)

eval event

     timestamp

     function
          An E-Lisp function to call when this event is dispatched.

     object
          The object to pass to the function.  The function and object are set when the event is created.

 -- Function: event-type event
     Return the type of EVENT.

     This will be a symbol; one of

     key-press
          A key was pressed.

     button-press
          A mouse button was pressed.

     button-release
          A mouse button was released.

     motion
          The mouse moved.

     misc-user
          Some other user action happened; typically, this is a menu selection, scrollbar action, or drag and drop action.

     process
          Input is available from a subprocess.

     timeout
          A timeout has expired.

     eval
          This causes a specified action to occur when dispatched.

     magic
          Some window-system-specific event has occurred.

Event Predicates
----------------

The following predicates return whether an object is an event of a particular type.

 -- Function: key-press-event-p object
     This is true if OBJECT is a key-press event.

 -- Function: button-event-p object object
     This is true if OBJECT is a mouse button-press or button-release event.

 -- Function: button-press-event-p object
     This is true if OBJECT is a mouse button-press event.

 -- Function: button-release-event-p object
     This is true if OBJECT is a mouse button-release event.

 -- Function: motion-event-p object
     This is true if OBJECT is a mouse motion event.

 -- Function: mouse-event-p object
     This is true if OBJECT is a mouse button-press, button-release or motion event.

 -- Function: eval-event-p object
     This is true if OBJECT is an eval event.

 -- Function: misc-user-event-p object
     This is true if OBJECT is a misc-user event.

 -- Function: process-event-p object
     This is true if OBJECT is a process event.

 -- Function: timeout-event-p object
     This is true if OBJECT is a timeout event.

 -- Function: event-live-p object
     This is true if OBJECT is any event that has not been deallocated.

Accessing the Position of a Mouse Event
---------------------------------------

Unlike other events, mouse events (i.e. motion, button-press, button-release, and drag or drop type misc-user events) occur in a particular location on the screen. Many primitives are provided for determining exactly where the event occurred and what is under that location.

Frame-Level Event Position Info
...............................

The following functions return frame-level information about where a mouse event occurred.

 -- Function: event-frame event
     This function returns the ``channel'' or frame that the given mouse motion, button press, button release, or misc-user event occurred in. This will be nil for non-mouse events.

 -- Function: event-x-pixel event
     This function returns the X position in pixels of the given mouse event. The value returned is relative to the frame the event occurred in. This will signal an error if the event is not a mouse event.

 -- Function: event-y-pixel event
     This function returns the Y position in pixels of the given mouse event. The value returned is relative to the frame the event occurred in. This will signal an error if the event is not a mouse event.

Window-Level Event Position Info
................................

The following functions return window-level information about where a mouse event occurred.

 -- Function: event-window event
     Given a mouse motion, button press, button release, or misc-user event, compute and return the window on which that event occurred.  This may be nil if the event occurred in the border or over a toolbar.  The modeline is considered to be within the window it describes.

 -- Function: event-buffer event
     Given a mouse motion, button press, button release, or misc-user event, compute and return the buffer of the window on which that event occurred.  This may be nil if the event occurred in the border or over a toolbar. The modeline is considered to be within the window it describes.  This is equivalent to calling event-window and then calling window-buffer on the result if it is a window.

 -- Function: event-window-x-pixel event
     This function returns the X position in pixels of the given mouse event. The value returned is relative to the window the event occurred in. This will signal an error if the event is not a mouse-motion, button-press, button-release, or misc-user event.

 -- Function: event-window-y-pixel event
     This function returns the Y position in pixels of the given mouse event. The value returned is relative to the window the event occurred in. This will signal an error if the event is not a mouse-motion, button-press, button-release, or misc-user event.

Event Text Position Info
........................

The following functions return information about the text (including the modeline) that a mouse event occurred over or near.

 -- Function: event-over-text-area-p event
     Given a mouse-motion, button-press, button-release, or misc-user event, this function returns t if the event is over the text area of a window.  Otherwise, nil is returned.  The modeline is not considered to be part of the text area.

 -- Function: event-over-modeline-p event
     Given a mouse-motion, button-press, button-release, or misc-user event, this function returns t if the event is over the modeline of a window. Otherwise, nil is returned.

 -- Function: event-x event
     This function returns the X position of the given mouse-motion, button-press, button-release, or misc-user event in characters.  This is relative to the window the event occurred over.

 -- Function: event-y event
     This function returns the Y position of the given mouse-motion, button-press, button-release, or misc-user event in characters.  This is relative to the window the event occurred over.

 -- Function: event-point event
     This function returns the character position of the given mouse-motion, button-press, button-release, or misc-user event.  If the event did not occur over a window, or did not occur over text, then this returns nil. Otherwise, it returns an index into the buffer visible in the event's window.

 -- Function: event-closest-point event
     This function returns the character position of the given mouse-motion, button-press, button-release, or misc-user event.  If the event did not occur over a window or over text, it returns the closest point to the location of the event.  If the Y pixel position overlaps a window and the X pixel position is to the left of that window, the closest point is the beginning of the line containing the Y position.  If the Y pixel position overlaps a window and the X pixel position is to the right of that window, the closest point is the end of the line containing the Y position.  If the Y pixel position is above a window, 0 is returned.  If it is below a window, the value of (window-end) is returned.

Event Glyph Position Info
.........................

The following functions return information about the glyph (if any) that a mouse event occurred over.

 -- Function: event-over-glyph-p event
     Given a mouse-motion, button-press, button-release, or misc-user event, this function returns t if the event is over a glyph.  Otherwise, nil is returned.

 -- Function: event-glyph-extent event
     If the given mouse-motion, button-press, button-release, or misc-user event happened on top of a glyph, this returns its extent; else nil is returned.

 -- Function: event-glyph-x-pixel event
     Given a mouse-motion, button-press, button-release, or misc-user event over a glyph, this function returns the X position of the pointer relative to the upper left of the glyph.  If the event is not over a glyph, it returns nil.

 -- Function: event-glyph-y-pixel event
     Given a mouse-motion, button-press, button-release, or misc-user event over a glyph, this function returns the Y position of the pointer relative to the upper left of the glyph.  If the event is not over a glyph, it returns nil.

Event Toolbar Position Info
...........................

 -- Function: event-over-toolbar-p event
     Given a mouse-motion, button-press, button-release, or misc-user event, this function returns t if the event is over a toolbar.  Otherwise, nil is returned.

 -- Function: event-toolbar-button event
     If the given mouse-motion, button-press, button-release, or misc-user event happened on top of a toolbar button, this function returns the button. Otherwise, nil is returned.

Other Event Position Info
.........................

 -- Function: event-over-border-p event
     Given a mouse-motion, button-press, button-release, or misc-user event, this function returns t if the event is over an internal toolbar. Otherwise, nil is returned.

Accessing the Other Contents of Events
--------------------------------------

The following functions allow access to the contents of events other than the position info described in the previous section.

 -- Function: event-timestamp event
     This function returns the timestamp of the given event object.

 -- Function: event-device event
     This function returns the device that the given event occurred on.

 -- Function: event-key event
     This function returns the Keysym of the given key-press event. This will be the ASCII code of a printing character, or a symbol.

 -- Function: event-button event
     This function returns the button-number of the given button-press or button-release event.

 -- Function: event-modifiers event
     This function returns a list of symbols, the names of the modifier keys which were down when the given mouse or keyboard event was produced.

 -- Function: event-modifier-bits event
     This function returns a number representing the modifier keys which were down when the given mouse or keyboard event was produced.

 -- Function: event-function event
     This function returns the callback function of the given timeout, misc-user, or eval event.

 -- Function: event-object event
     This function returns the callback function argument of the given timeout, misc-user, or eval event.

 -- Function: event-process event
     This function returns the process of the given process event.

Working With Events
-------------------

XEmacs provides primitives for creating, copying, and destroying event objects.  Many functions that return events take an event object as an argument and fill in the fields of this event; or they make accept either an event object or nil, creating the event object first in the latter case.

 -- Function: make-event &optional type plist
     This function creates a new event structure.  If no arguments are specified, the created event will be empty.  To specify the event type, use the TYPE argument.  The allowed types are empty, key-press, button-press, button-release, motion, or misc-user.

     PLIST is a property list, the properties being compatible to those returned by event-properties.  For events other than empty, it is mandatory to specify certain properties.  For empty events, PLIST must be nil.  The list is canonicalized, which means that if a property keyword is present more than once, only the first instance is taken into account. Specifying an unknown or illegal property signals an error.

     The following properties are allowed:

     channel
          The event channel.  This is a frame or a console.  For mouse events (of type button-press, button-release and motion), this must be a frame.  For key-press events, it must be a console.  If channel is unspecified by PLIST, it will be set to the selected frame or selected console, as appropriate.

     key
          The event key.  This is either a symbol or a character.  It is allowed (and required) only for key-press events.

     button
          The event button.  This an integer, either 1, 2 or 3.  It is allowed only for button-press and button-release events.

     modifiers
          The event modifiers.  This is a list of modifier symbols.  It is allowed for key-press, button-press, button-release and motion events.

     x
          The event X coordinate.  This is an integer.  It is relative to the channel's root window, and is allowed for button-press, button-release and motion events.

     y
          The event Y coordinate.  This is an integer.  It is relative to the channel's root window, and is allowed for button-press, button-release and motion events.  This means that, for instance, to access the toolbar, the y property will have to be negative.

     timestamp
          The event timestamp, a non-negative integer.  Allowed for all types of events.

     WARNING: the event object returned by this function may be a reused one; see the function deallocate-event.

     The events created by make-event can be used as non-interactive arguments to the functions with an (interactive "e") specification.

     Here are some basic examples of usage:

          ;; Create an empty event.
          (make-event)
               => #<empty-event>

          ;; Try creating a key-press event.
          (make-event 'key-press)
               error--> Undefined key for keypress event

          ;; Creating a key-press event, try 2
          (make-event 'key-press '(key home))
               => #<keypress-event home>

          ;; Create a key-press event of dubious fame.
          (make-event 'key-press '(key escape modifiers (meta alt control shift)))
               => #<keypress-event control-meta-alt-shift-escape>

          ;; Create a M-button1 event at coordinates defined by variables
          ;; X and Y.
          (make-event 'button-press `(button 1 modifiers (meta) x ,x y ,y))
               => #<buttondown-event meta-button1>

          ;; Create a simmilar button-release event.
          (make-event 'button-release `(button 1 modifiers (meta) x ,x y ,x))
               => #<buttonup-event meta-button1up>

          ;; Create a mouse-motion event.
          (make-event 'motion '(x 20 y 30))
               => #<motion-event 20, 30>

          (event-properties (make-event 'motion '(x 20 y 30)))
               => (channel #<x-frame "emacs" 0x8e2> x 20 y 30
                   modifiers nil timestamp 0)

     In conjunction with event-properties, you can use make-event to create modified copies of existing events.  For instance, the following code will return an equal copy of EVENT:

          (make-event (event-type EVENT)
                      (event-properties EVENT))

     Note, however, that you cannot use make-event as the generic replacement for copy-event, because it does not allow creating all of the event types.

     To create a modified copy of an event, you can use the canonicalization feature of PLIST.  The following example creates a copy of EVENT, but with modifiers reset to nil.

          (make-event (event-type EVENT)
                      (append '(modifiers nil)
                              (event-properties EVENT)))

 -- Function: copy-event event1 &optional event2
     This function makes a copy of the given event object.  If a second argument is given, the first event is copied into the second and the second is returned.  If the second argument is not supplied (or is nil) then a new event will be made.

 -- Function: deallocate-event event
     This function allows the given event structure to be reused.  You MUST NOT use this event object after calling this function with it.  You will lose.  It is not necessary to call this function, as event objects are garbage-collected like all other objects; however, it may be more efficient to explicitly deallocate events when you are sure that that is safe.

Converting Events
-----------------

XEmacs provides some auxiliary functions for converting between events and other ways of representing keys.  These are useful when working with ASCII strings and with keymaps.

 -- Function: character-to-event ch &optional event device
     This function converts a numeric ASCII value to an event structure, replete with modifier bits.  CH is the character to convert, and EVENT is the event object to fill in.  This function contains knowledge about what the codes ``mean'' -- for example, the number 9 is converted to the character Tab, not the distinct character Control-I.

     Note that CH does not have to be a numeric value, but can be a symbol such as clear or a list such as (control backspace).

     If event is not nil, it is modified; otherwise, a new event object is created.  In both cases, the event is returned.

     Optional third arg DEVICE is the device to store in the event; this also affects whether the high bit is interpreted as a meta key.  A value of nil means use the selected device but always treat the high bit as meta.

     Beware that character-to-event and event-to-character are not strictly inverse functions, since events contain much more information than the ASCII character set can encode.

 -- Function: event-to-character event &optional allow-extra-modifiers allow-meta allow-non-ascii
     This function returns the closest ASCII approximation to EVENT.  If the event isn't a keypress, this returns nil.

     If ALLOW-EXTRA-MODIFIERS is non-nil, then this is lenient in its translation; it will ignore modifier keys other than control and meta, and will ignore the shift modifier on those characters which have no shifted ASCII equivalent (Control-Shift-A for example, will be mapped to the same ASCII code as Control-A).

     If ALLOW-META is non-nil, then the Meta modifier will be represented by turning on the high bit of the byte returned; otherwise, nil will be returned for events containing the Meta modifier.

     If ALLOW-NON-ASCII is non-nil, then characters which are present in the prevailing character set (see variable character-set-property) will be returned as their code in that character set, instead of the return value being restricted to ASCII.

     Note that specifying both ALLOW-META and ALLOW-NON-ASCII is ambiguous, as both use the high bit; M-x and oslash will be indistinguishable.

 -- Function: events-to-keys events &optional no-mice
     Given a vector of event objects, this function returns a vector of key descriptors, or a string (if they all fit in the ASCII range). Optional arg NO-MICE means that button events are not allowed.

Reading Input
=============

The editor command loop reads keyboard input using the function next-event and constructs key sequences out of the events using dispatch-event.  Lisp programs can also use the function read-key-sequence, which reads input a key sequence at a time. See also momentary-string-display in Temporary Displays, and sit-for in Waiting.  See Terminal Input, for functions and variables for controlling terminal input modes and debugging terminal input.

For higher-level input facilities, see Minibuffers.

Key Sequence Input
------------------

Lisp programs can read input a key sequence at a time by calling read-key-sequence; for example, describe-key uses it to read the key to describe.

 -- Function: read-key-sequence prompt
     This function reads a sequence of keystrokes or mouse clicks and returns it as a vector of events.  It keeps reading events until it has accumulated a full key sequence; that is, enough to specify a non-prefix command using the currently active keymaps.

     The vector and the event objects it contains are freshly created, and will not be side-effected by subsequent calls to this function.

     The function read-key-sequence suppresses quitting: C-g typed while reading with this function works like any other character, and does not set quit-flag.  See Quitting.

     The argument PROMPT is either a string to be displayed in the echo area as a prompt, or nil, meaning not to display a prompt.

     If the user selects a menu item while we are prompting for a key sequence, the returned value will be a vector of a single menu-selection event (a misc-user event).  An error will be signalled if you pass this value to lookup-key or a related function.

     In the example below, the prompt ? is displayed in the echo area, and the user types C-x C-f.

          (read-key-sequence "?")

          ---------- Echo Area ----------
          ?C-x C-f
          ---------- Echo Area ----------

               => [#<keypress-event control-X> #<keypress-event control-F>]

If an input character is an upper-case letter and has no key binding, but its lower-case equivalent has one, then read-key-sequence converts the character to lower case.  Note that lookup-key does not perform case conversion in this way.

Reading One Event
-----------------

The lowest level functions for command input are those which read a single event.  These functions often make a distinction between command events, which are user actions (keystrokes and mouse actions), and other events, which serve as communication between XEmacs and the window system.

 -- Function: next-event &optional event prompt
     This function reads and returns the next available event from the window system or terminal driver, waiting if necessary until an event is available.  Pass this object to dispatch-event to handle it. If an event object is supplied, it is filled in and returned; otherwise a new event object will be created.

     Events can come directly from the user, from a keyboard macro, or from unread-command-events.

     In most cases, the function next-command-event is more appropriate.

 -- Function: next-command-event &optional event
     This function returns the next available ``user'' event from the window system or terminal driver.  Pass this object to dispatch-event to handle it.  If an event object is supplied, it is filled in and returned, otherwise a new event object will be created.

     The event returned will be a keyboard, mouse press, or mouse release event.  If there are non-command events available (mouse motion, sub-process output, etc) then these will be executed (with dispatch-event) and discarded.  This function is provided as a convenience; it is equivalent to the Lisp code

          	(while (progn
          		 (next-event event)
          	         (not (or (key-press-event-p event)
          	                  (button-press-event-p event)
          	                  (button-release-event-p event)
          	                  (menu-event-p event))))
          	   (dispatch-event event))

     Here is what happens if you call next-command-event and then press the right-arrow function key:

          (next-command-event)
               => #<keypress-event right>

 -- Function: read-char
     This function reads and returns a character of command input.  If a mouse click is detected, an error is signalled.  The character typed is returned as an ASCII value.  This function is retained for compatibility with Emacs 18, and is most likely the wrong thing for you to be using: consider using next-command-event instead.

 -- Function: enqueue-eval-event function object
     This function adds an eval event to the back of the queue.  The eval event will be the next event read after all pending events.

Dispatching an Event
--------------------

 -- Function: dispatch-event event
     Given an event object returned by next-event, this function executes it.  This is the basic function that makes XEmacs respond to user input; it also deals with notifications from the window system (such as Expose events).

Quoted Character Input
----------------------

You can use the function read-quoted-char to ask the user to specify a character, and allow the user to specify a control or meta character conveniently, either literally or as an octal character code. The command quoted-insert uses this function.

 -- Function: read-quoted-char &optional prompt
     This function is like read-char, except that if the first character read is an octal digit (0-7), it reads up to two more octal digits (but stopping if a non-octal digit is found) and returns the character represented by those digits in octal.

     Quitting is suppressed when the first character is read, so that the user can enter a C-g.  See Quitting.

     If PROMPT is supplied, it specifies a string for prompting the user.  The prompt string is always displayed in the echo area, followed by a single -.

     In the following example, the user types in the octal number 177 (which is 127 in decimal).

          (read-quoted-char "What character")

          ---------- Echo Area ----------
          What character-177
          ---------- Echo Area ----------

               => 127

Miscellaneous Event Input Features
----------------------------------

This section describes how to ``peek ahead'' at events without using them up, how to check for pending input, and how to discard pending input.

See also the variables last-command-event and last-command-char (Command Loop Info).

 -- Variable: unread-command-events
     This variable holds a list of events waiting to be read as command input.  The events are used in the order they appear in the list, and removed one by one as they are used.

     The variable is needed because in some cases a function reads a event and then decides not to use it.  Storing the event in this variable causes it to be processed normally, by the command loop or by the functions to read command input.

     For example, the function that implements numeric prefix arguments reads any number of digits.  When it finds a non-digit event, it must unread the event so that it can be read normally by the command loop. Likewise, incremental search uses this feature to unread events with no special meaning in a search, because these events should exit the search and then execute normally.

 -- Variable: unread-command-event
     This variable holds a single event to be read as command input.

     This variable is mostly obsolete now that you can use unread-command-events instead; it exists only to support programs written for versions of XEmacs prior to 19.12.

 -- Function: input-pending-p
     This function determines whether any command input is currently available to be read.  It returns immediately, with value t if there is available input, nil otherwise.  On rare occasions it may return t when no input is available.

 -- Variable: last-input-event
     This variable is set to the last keyboard or mouse button event received.

     This variable is off limits: you may not set its value or modify the event that is its value, as it is destructively modified by read-key-sequence.  If you want to keep a pointer to this value, you must use copy-event.

     Note that this variable is an alias for last-input-char in FSF Emacs.

     In the example below, a character is read (the character 1).  It becomes the value of last-input-event, while C-e (from the C-x C-e command used to evaluate this expression) remains the value of last-command-event.

          (progn (print (next-command-event))
                 (print last-command-event)
                 last-input-event)
               -| #<keypress-event 1>
               -| #<keypress-event control-E>
               => #<keypress-event 1>

 -- Variable: last-input-char
     If the value of last-input-event is a keyboard event, then this is the nearest ASCII equivalent to it.  Remember that there is not a 1:1 mapping between keyboard events and ASCII characters: the set of keyboard events is much larger, so writing code that examines this variable to determine what key has been typed is bad practice, unless you are certain that it will be one of a small set of characters.

     This function exists for compatibility with Emacs version 18.

 -- Function: discard-input
     This function discards the contents of the terminal input buffer and cancels any keyboard macro that might be in the process of definition. It returns nil.

     In the following example, the user may type a number of characters right after starting the evaluation of the form.  After the sleep-for finishes sleeping, discard-input discards any characters typed during the sleep.

          (progn (sleep-for 2)
                 (discard-input))
               => nil

Waiting for Elapsed Time or Input
=================================

The wait functions are designed to wait for a certain amount of time to pass or until there is input.  For example, you may wish to pause in the middle of a computation to allow the user time to view the display. sit-for pauses and updates the screen, and returns immediately if input comes in, while sleep-for pauses without updating the screen.

Note that in FSF Emacs, the commands sit-for and sleep-for take two arguments to specify the time (one integer and one float value), instead of a single argument that can be either an integer or a float.

 -- Function: sit-for seconds &optional nodisp
     This function performs redisplay (provided there is no pending input from the user), then waits SECONDS seconds, or until input is available.  The result is t if sit-for waited the full time with no input arriving (see input-pending-p in Peeking and Discarding).  Otherwise, the value is nil.

     The argument SECONDS need not be an integer.  If it is a floating point number, sit-for waits for a fractional number of seconds.

     Redisplay is normally preempted if input arrives, and does not happen at all if input is available before it starts. (You can force screen updating in such a case by using force-redisplay.  See Refresh Screen.) If there is no input pending, you can force an update with no delay by using (sit-for 0).

     If NODISP is non-nil, then sit-for does not redisplay, but it still returns as soon as input is available (or when the timeout elapses).

     The usual purpose of sit-for is to give the user time to read text that you display.

 -- Function: sleep-for seconds
     This function simply pauses for SECONDS seconds without updating the display.  This function pays no attention to available input.  It returns nil.

     The argument SECONDS need not be an integer.  If it is a floating point number, sleep-for waits for a fractional number of seconds.

     Use sleep-for when you wish to guarantee a delay.

See Time of Day, for functions to get the current time.

Quitting
========

Typing C-g while a Lisp function is running causes XEmacs to quit whatever it is doing.  This means that control returns to the innermost active command loop.

Typing C-g while the command loop is waiting for keyboard input does not cause a quit; it acts as an ordinary input character.  In the simplest case, you cannot tell the difference, because C-g normally runs the command keyboard-quit, whose effect is to quit. However, when C-g follows a prefix key, the result is an undefined key.  The effect is to cancel the prefix key as well as any prefix argument.

In the minibuffer, C-g has a different definition: it aborts out of the minibuffer.  This means, in effect, that it exits the minibuffer and then quits.  (Simply quitting would return to the command loop within the minibuffer.)  The reason why C-g does not quit directly when the command reader is reading input is so that its meaning can be redefined in the minibuffer in this way.  C-g following a prefix key is not redefined in the minibuffer, and it has its normal effect of canceling the prefix key and prefix argument.  This too would not be possible if C-g always quit directly.

When C-g does directly quit, it does so by setting the variable quit-flag to t.  XEmacs checks this variable at appropriate times and quits if it is not nil.  Setting quit-flag non-nil in any way thus causes a quit.

At the level of C code, quitting cannot happen just anywhere; only at the special places that check quit-flag.  The reason for this is that quitting at other places might leave an inconsistency in XEmacs's internal state.  Because quitting is delayed until a safe place, quitting cannot make XEmacs crash.

Certain functions such as read-key-sequence or read-quoted-char prevent quitting entirely even though they wait for input.  Instead of quitting, C-g serves as the requested input.  In the case of read-key-sequence, this serves to bring about the special behavior of C-g in the command loop.  In the case of read-quoted-char, this is so that C-q can be used to quote a C-g.

You can prevent quitting for a portion of a Lisp function by binding the variable inhibit-quit to a non-nil value.  Then, although C-g still sets quit-flag to t as usual, the usual result of this---a quit---is prevented.  Eventually, inhibit-quit will become nil again, such as when its binding is unwound at the end of a let form.  At that time, if quit-flag is still non-nil, the requested quit happens immediately.  This behavior is ideal when you wish to make sure that quitting does not happen within a ``critical section'' of the program.

In some functions (such as read-quoted-char), C-g is handled in a special way that does not involve quitting.  This is done by reading the input with inhibit-quit bound to t, and setting quit-flag to nil before inhibit-quit becomes nil again.  This excerpt from the definition of read-quoted-char shows how this is done; it also shows that normal quitting is permitted after the first character of input.

     (defun read-quoted-char (&optional prompt)
       "...DOCUMENTATION..."
       (let ((count 0) (code 0) char)
         (while (< count 3)
           (let ((inhibit-quit (zerop count))
                 (help-form nil))
             (and prompt (message "%s-" prompt))
             (setq char (read-char))
             (if inhibit-quit (setq quit-flag nil)))
           ...)
         (logand 255 code)))

 -- Variable: quit-flag
     If this variable is non-nil, then XEmacs quits immediately, unless inhibit-quit is non-nil.  Typing C-g ordinarily sets quit-flag non-nil, regardless of inhibit-quit.

 -- Variable: inhibit-quit
     This variable determines whether XEmacs should quit when quit-flag is set to a value other than nil.  If inhibit-quit is non-nil, then quit-flag has no special effect.

 -- Command: keyboard-quit
     This function signals the quit condition with (signal 'quit nil).  This is the same thing that quitting does.  (See signal in Errors.)

You can specify a character other than C-g to use for quitting. See the function set-input-mode in Terminal Input.

Prefix Command Arguments
========================

Most XEmacs commands can use a prefix argument, a number specified before the command itself.  (Don't confuse prefix arguments with prefix keys.)  The prefix argument is at all times represented by a value, which may be nil, meaning there is currently no prefix argument.  Each command may use the prefix argument or ignore it.

There are two representations of the prefix argument: raw and numeric.  The editor command loop uses the raw representation internally, and so do the Lisp variables that store the information, but commands can request either representation.

Here are the possible values of a raw prefix argument:

  * nil, meaning there is no prefix argument.  Its numeric value is 1, but numerous commands make a distinction between nil and the integer 1.

  * An integer, which stands for itself.

  * A list of one element, which is an integer.  This form of prefix argument results from one or a succession of C-u's with no digits.  The numeric value is the integer in the list, but some commands make a distinction between such a list and an integer alone.

  * The symbol -.  This indicates that M-- or C-u - was typed, without following digits.  The equivalent numeric value is -1, but some commands make a distinction between the integer -1 and the symbol -.

We illustrate these possibilities by calling the following function with various prefixes:

     (defun display-prefix (arg)
       "Display the value of the raw prefix arg."
       (interactive "P")
       (message "%s" arg))

Here are the results of calling display-prefix with various raw prefix arguments:

             M-x display-prefix  -| nil

     C-u     M-x display-prefix  -| (4)

     C-u C-u M-x display-prefix  -| (16)

     C-u 3   M-x display-prefix  -| 3

     M-3     M-x display-prefix  -| 3      ; (Same as C-u 3.)

     C-3     M-x display-prefix  -| 3      ; (Same as C-u 3.)

     C-u -   M-x display-prefix  -| -

     M--     M-x display-prefix  -| -      ; (Same as C-u -.)

     C--     M-x display-prefix  -| -      ; (Same as C-u -.)

     C-u - 7 M-x display-prefix  -| -7

     M-- 7   M-x display-prefix  -| -7     ; (Same as C-u -7.)

     C-- 7   M-x display-prefix  -| -7     ; (Same as C-u -7.)

XEmacs uses two variables to store the prefix argument: prefix-arg and current-prefix-arg.  Commands such as universal-argument that set up prefix arguments for other commands store them in prefix-arg.  In contrast, current-prefix-arg conveys the prefix argument to the current command, so setting it has no effect on the prefix arguments for future commands.

Normally, commands specify which representation to use for the prefix argument, either numeric or raw, in the interactive declaration. (see Using Interactive.)  Alternatively, functions may look at the value of the prefix argument directly in the variable current-prefix-arg, but this is less clean.

 -- Function: prefix-numeric-value arg
     This function returns the numeric meaning of a valid raw prefix argument value, ARG.  The argument may be a symbol, a number, or a list. If it is nil, the value 1 is returned; if it is -, the value -1 is returned; if it is a number, that number is returned; if it is a list, the CAR of that list (which should be a number) is returned.

 -- Variable: current-prefix-arg
     This variable holds the raw prefix argument for the current command.  Commands may examine it directly, but the usual way to access it is with (interactive "P").

 -- Variable: prefix-arg
     The value of this variable is the raw prefix argument for the next editing command.  Commands that specify prefix arguments for the following command work by setting this variable.

Do not call the functions universal-argument, digit-argument, or negative-argument unless you intend to let the user enter the prefix argument for the next command.

 -- Command: universal-argument
     This command reads input and specifies a prefix argument for the following command.  Don't call this command yourself unless you know what you are doing.

 -- Command: digit-argument arg
     This command adds to the prefix argument for the following command.  The argument ARG is the raw prefix argument as it was before this command; it is used to compute the updated prefix argument.  Don't call this command yourself unless you know what you are doing.

 -- Command: negative-argument arg
     This command adds to the numeric argument for the next command.  The argument ARG is the raw prefix argument as it was before this command; its value is negated to form the new prefix argument.  Don't call this command yourself unless you know what you are doing.

Recursive Editing
=================

The XEmacs command loop is entered automatically when XEmacs starts up. This top-level invocation of the command loop never exits; it keeps running as long as XEmacs does.  Lisp programs can also invoke the command loop.  Since this makes more than one activation of the command loop, we call it recursive editing.  A recursive editing level has the effect of suspending whatever command invoked it and permitting the user to do arbitrary editing before resuming that command.

The commands available during recursive editing are the same ones available in the top-level editing loop and defined in the keymaps. Only a few special commands exit the recursive editing level; the others return to the recursive editing level when they finish.  (The special commands for exiting are always available, but they do nothing when recursive editing is not in progress.)

All command loops, including recursive ones, set up all-purpose error handlers so that an error in a command run from the command loop will not exit the loop.

Minibuffer input is a special kind of recursive editing.  It has a few special wrinkles, such as enabling display of the minibuffer and the minibuffer window, but fewer than you might suppose.  Certain keys behave differently in the minibuffer, but that is only because of the minibuffer's local map; if you switch windows, you get the usual XEmacs commands.

To invoke a recursive editing level, call the function recursive-edit.  This function contains the command loop; it also contains a call to catch with tag exit, which makes it possible to exit the recursive editing level by throwing to exit (see Catch and Throw).  If you throw a value other than t, then recursive-edit returns normally to the function that called it.  The command C-M-c (exit-recursive-edit) does this. Throwing a t value causes recursive-edit to quit, so that control returns to the command loop one level up.  This is called aborting, and is done by C-] (abort-recursive-edit).

Most applications should not use recursive editing, except as part of using the minibuffer.  Usually it is more convenient for the user if you change the major mode of the current buffer temporarily to a special major mode, which should have a command to go back to the previous mode. (The e command in Rmail uses this technique.)  Or, if you wish to give the user different text to edit ``recursively'', create and select a new buffer in a special mode.  In this mode, define a command to complete the processing and go back to the previous buffer.  (The m command in Rmail does this.)

Recursive edits are useful in debugging.  You can insert a call to debug into a function definition as a sort of breakpoint, so that you can look around when the function gets there.  debug invokes a recursive edit but also provides the other features of the debugger.

Recursive editing levels are also used when you type C-r in query-replace or use C-x q (kbd-macro-query).

 -- Function: recursive-edit
     This function invokes the editor command loop.  It is called automatically by the initialization of XEmacs, to let the user begin editing.  When called from a Lisp program, it enters a recursive editing level.

     In the following example, the function simple-rec first advances point one word, then enters a recursive edit, printing out a message in the echo area.  The user can then do any editing desired, and then type C-M-c to exit and continue executing simple-rec.

          (defun simple-rec ()
            (forward-word 1)
            (message "Recursive edit in progress")
            (recursive-edit)
            (forward-word 1))
               => simple-rec
          (simple-rec)
               => nil

 -- Command: exit-recursive-edit
     This function exits from the innermost recursive edit (including minibuffer input).  Its definition is effectively (throw 'exit nil).

 -- Command: abort-recursive-edit
     This function aborts the command that requested the innermost recursive edit (including minibuffer input), by signaling quit after exiting the recursive edit.  Its definition is effectively (throw 'exit t).  See Quitting.

 -- Command: top-level
     This function exits all recursive editing levels; it does not return a value, as it jumps completely out of any computation directly back to the main command loop.

 -- Function: recursion-depth
     This function returns the current depth of recursive edits.  When no recursive edit is active, it returns 0.

Disabling Commands
==================

Disabling a command marks the command as requiring user confirmation before it can be executed.  Disabling is used for commands which might be confusing to beginning users, to prevent them from using the commands by accident.

The low-level mechanism for disabling a command is to put a non-nil disabled property on the Lisp symbol for the command.  These properties are normally set up by the user's .emacs file with Lisp expressions such as this:

     (put 'upcase-region 'disabled t)

For a few commands, these properties are present by default and may be removed by the .emacs file.

If the value of the disabled property is a string, the message saying the command is disabled includes that string.  For example:

     (put 'delete-region 'disabled
          "Text deleted this way cannot be yanked back!\n")

See Disabling (The XEmacs User's Manual), for the details on what happens when a disabled command is invoked interactively. Disabling a command has no effect on calling it as a function from Lisp programs.

 -- Command: enable-command command
     Allow COMMAND to be executed without special confirmation from now on, and (if the user confirms) alter the user's .emacs file so that this will apply to future sessions.

 -- Command: disable-command command
     Require special confirmation to execute COMMAND from now on, and (if the user confirms) alter the user's .emacs file so that this will apply to future sessions.

 -- Variable: disabled-command-hook
     This normal hook is run instead of a disabled command, when the user invokes the disabled command interactively.  The hook functions can use this-command-keys to determine what the user typed to run the command, and thus find the command itself.  See Hooks.

     By default, disabled-command-hook contains a function that asks the user whether to proceed.

Command History
===============

The command loop keeps a history of the complex commands that have been executed, to make it convenient to repeat these commands.  A complex command is one for which the interactive argument reading uses the minibuffer.  This includes any M-x command, any M-: command, and any command whose interactive specification reads an argument from the minibuffer.  Explicit use of the minibuffer during the execution of the command itself does not cause the command to be considered complex.

 -- Variable: command-history
     This variable's value is a list of recent complex commands, each represented as a form to evaluate.  It continues to accumulate all complex commands for the duration of the editing session, but all but the first (most recent) thirty elements are deleted when a garbage collection takes place (see Garbage Collection).

          command-history
          => ((switch-to-buffer "chistory.texi")
              (describe-key "^X^[")
              (visit-tags-table "~/emacs/src/")
              (find-tag "repeat-complex-command"))

This history list is actually a special case of minibuffer history (see Minibuffer History), with one special twist: the elements are expressions rather than strings.

There are a number of commands devoted to the editing and recall of previous commands.  The commands repeat-complex-command, and list-command-history are described in the user manual (see Repetition (The XEmacs User's Manual)).  Within the minibuffer, the history commands used are the same ones available in any minibuffer.

Keyboard Macros
===============

A keyboard macro is a canned sequence of input events that can be considered a command and made the definition of a key.  The Lisp representation of a keyboard macro is a string or vector containing the events.  Don't confuse keyboard macros with Lisp macros (see Macros).

 -- Function: execute-kbd-macro macro &optional count
     This function executes MACRO as a sequence of events.  If MACRO is a string or vector, then the events in it are executed exactly as if they had been input by the user.  The sequence is not expected to be a single key sequence; normally a keyboard macro definition consists of several key sequences concatenated.

     If MACRO is a symbol, then its function definition is used in place of MACRO.  If that is another symbol, this process repeats. Eventually the result should be a string or vector.  If the result is not a symbol, string, or vector, an error is signaled.

     The argument COUNT is a repeat count; MACRO is executed that many times.  If COUNT is omitted or nil, MACRO is executed once.  If it is 0, MACRO is executed over and over until it encounters an error or a failing search.

 -- Variable: executing-macro
     This variable contains the string or vector that defines the keyboard macro that is currently executing.  It is nil if no macro is currently executing.  A command can test this variable to behave differently when run from an executing macro.  Do not set this variable yourself.

 -- Variable: defining-kbd-macro
     This variable indicates whether a keyboard macro is being defined.  A command can test this variable to behave differently while a macro is being defined.  The commands start-kbd-macro and end-kbd-macro set this variable---do not set it yourself.

 -- Variable: last-kbd-macro
     This variable is the definition of the most recently defined keyboard macro.  Its value is a string or vector, or nil.

The commands are described in the user's manual (see Keyboard Macros (The XEmacs User's Manual)).