Go to the previous, next section.
A Lisp program consists of expressions or forms (see section Kinds of Forms). We control the order of execution of the forms by enclosing them in control structures. Control structures are special forms which control when, whether, or how many times to execute the forms they contain.
The simplest control structure is sequential execution: first form a, then form b, and so on. This is what happens when you write several forms in succession in the body of a function, or at top level in a file of Lisp code--the forms are executed in the order they are written. We call this textual order. For example, if a function body consists of two forms a and b, evaluation of the function evaluates first a and then b, and the function's value is the value of b.
Naturally, Emacs Lisp has many kinds of control structures, including other varieties of sequencing, function calls, conditionals, iteration, and (controlled) jumps. The built-in control structures are special forms since their subforms are not necessarily evaluated. You can use macros to define your own control structure constructs (see section Macros).
Evaluating forms in the order they are written is the most common
control structure. Sometimes this happens automatically, such as in a
function body. Elsewhere you must use a control structure construct to
progn, the simplest control construct of Lisp.
progn special form looks like this:
(progn a b c ...)
and it says to execute the forms a, b, c and so on, in
that order. These forms are called the body of the
The value of the last form in the body becomes the value of the entire
When Lisp was young,
progn was the only way to execute two or
more forms in succession and use the value of the last of them. But
programmers found they often needed to use a
progn in the body of
a function, where (at that time) only one form was allowed. So the body
of a function was made into an "implicit
progn": several forms
are allowed just as in the body of an actual
progn. Many other
control structures likewise contain an implicit
progn. As a
progn is not used as often as it used to be. It is
needed now most often inside of an
Special Form: progn forms...
This special form evaluates all of the forms, in textual order, returning the result of the final form.
(progn (print "The first form") (print "The second form") (print "The third form")) -| "The first form" -| "The second form" -| "The third form" => "The third form"
Two other control constructs likewise evaluate a series of forms but return a different value:
Special Form: prog1 form1 forms...
This special form evaluates form1 and all of the forms, in textual order, returning the result of form1.
(prog1 (print "The first form") (print "The second form") (print "The third form")) -| "The first form" -| "The second form" -| "The third form" => "The first form"
Here is a way to remove the first element from a list in the variable
x, then return the value of that former element:
(prog1 (car x) (setq x (cdr x)))
Special Form: prog2 form1 form2 forms...
This special form evaluates form1, form2, and all of the following forms, in textual order, returning the result of form2.
(prog2 (print "The first form") (print "The second form") (print "The third form")) -| "The first form" -| "The second form" -| "The third form" => "The second form"
Conditional control structures choose among alternatives. Emacs Lisp
has two conditional forms:
if, which is much the same as in other
cond, which is a generalized case statement.
Special Form: if condition then-form else-forms...
if chooses between the then-form and the else-forms
based on the value of condition. If the evaluated condition is
nil, then-form is evaluated and the result returned.
Otherwise, the else-forms are evaluated in textual order, and the
value of the last one is returned. (The else part of
an example of an implicit
progn. See section Sequencing.)
If condition has the value
nil, and no else-forms are
if is a special form because the branch which is not selected is
never evaluated--it is ignored. Thus, in the example below,
true is not printed because
(if nil (print 'true) 'very-false) => very-false
Special Form: cond clause...
cond chooses among an arbitrary number of alternatives. Each
clause in the
cond must be a list. The CAR of this
list is the condition; the remaining elements, if any, the
body-forms. Thus, a clause looks like this:
cond tries the clauses in textual order, by evaluating the
condition of each clause. If the value of condition is
nil, the body-forms are evaluated, and the value of the
last of body-forms becomes the value of the
remaining clauses are ignored.
If the value of condition is
nil, the clause "fails", so
cond moves on to the following clause, trying its
If every condition evaluates to
nil, so that every clause
A clause may also look like this:
Then, if condition is non-
nil when tested, the value of
condition becomes the value of the
The following example has four clauses, which test for the cases where
the value of
x is a number, string, buffer and symbol,
(cond ((numberp x) x) ((stringp x) x) ((bufferp x) (setq temporary-hack x) ; multiple body-forms (buffer-name x)) ; in one clause ((symbolp x) (symbol-value x)))
Often we want the last clause to be executed whenever none of the
previous clauses was successful. To do this, we use
t as the
condition of the last clause, like this:
body-forms). The form
t evaluates to
nil, so this clause never fails, provided the
cond gets to it at all.
(cond ((eq a 1) 'foo) (t "default")) => "default"
This expression is a
cond which returns
foo if the value
a is 1, and returns the string
if can usually be written in terms of the
other. Therefore, the choice between them is a matter of taste and
style. For example:
(if a b c) == (cond (a b) (t c))
This section describes three constructs that are often used together
cond to express complicated conditions. The
or can also be used individually as
kinds of multiple conditional constructs.
Function: not condition
This function tests for the falsehood of condition. It returns
t if condition is
not is identical to
null, and we recommend
null if you are testing for an empty list.
Special Form: and conditions...
and special form tests whether all the conditions are
true. It works by evaluating the conditions one by one in the
If any of the conditions evaluates to
nil, then the result
and must be
nil regardless of the remaining
conditions; so the remaining conditions are ignored and the
and returns right away.
If all the conditions turn out non-
nil, then the value of
the last of them becomes the value of the
Here is an example. The first condition returns the integer 1, which is
nil. Similarly, the second condition returns the integer 2,
which is not
nil. The third condition is
nil, so the
remaining condition is never evaluated.
(and (print 1) (print 2) nil (print 3)) -| 1 -| 2 => nil
Here is a more realistic example of using
(if (and (consp foo) (eq (car foo) 'x)) (message "foo is a list starting with x"))
(car foo) is not executed if
(consp foo) returns
nil, thus avoiding an error.
and can be expressed in terms of either
(and arg1 arg2 arg3) == (if arg1 (if arg2 arg3)) == (cond (arg1 (cond (arg2 arg3))))
Special Form: or conditions...
or special form tests whether at least one of the
conditions is true. It works by evaluating all the
conditions one by one in the order written.
If any of the conditions evaluates to a non-
nil value, then
the result of the
or must be non-
nil; so the remaining
conditions are ignored and the
or returns right away. The
value it returns is the non-
nil value of the condition just
If all the conditions turn out
nil, then the
For example, this expression tests whether
x is either 0 or
(or (eq x nil) (= x 0))
or can be written in terms of
cond. For example:
(or arg1 arg2 arg3) == (cond (arg1) (arg2) (arg3))
You could almost write
or in terms of
if, but not quite:
(if arg1 arg1 (if arg2 arg2 arg3))
This is not completely equivalent because it can evaluate arg1 or
arg2 twice. By contrast,
(or arg1 arg2
arg3) never evaluates any argument more than once.
Iteration means executing part of a program repetitively. For example,
you might want to repeat some expressions once for each element of a list,
or once for each integer from 0 to n. You can do this in Emacs Lisp
with the special form
Special Form: while condition forms...
while first evaluates condition. If the result is
nil, it evaluates forms in textual order. Then it
reevaluates condition, and if the result is non-
evaluates forms again. This process repeats until condition
There is no limit on the number of iterations that may occur. The loop
will continue until either condition evaluates to
until an error or
throw jumps out of it (see section Nonlocal Exits).
The value of a
while form is always
(setq num 0) => 0 (while (< num 4) (princ (format "Iteration %d." num)) (setq num (1+ num))) -| Iteration 0. -| Iteration 1. -| Iteration 2. -| Iteration 3. => nil
If you would like to execute something on each iteration before the
end-test, put it together with the end-test in a
progn as the
first argument of
while, as shown here:
(while (progn (forward-line 1) (not (looking-at "^$"))))
This moves forward one line and continues moving by lines until an empty line is reached.
A nonlocal exit is a transfer of control from one point in a program to another remote point. Nonlocal exits can occur in Emacs Lisp as a result of errors; you can also use them under explicit control. Nonlocal exits unbind all variable bindings made by the constructs being exited.
Most control constructs affect only the flow of control within the
construct itself. The function
throw is the exception to this
rule for of normal program execution: it performs a nonlocal exit on
request. (There are other exceptions, but they are for error handling
throw is used inside a
catch, and jumps back to
catch. For example:
(catch 'foo (progn ... (throw 'foo t) ...))
throw transfers control straight back to the corresponding
catch, which returns immediately. The code following the
throw is not executed. The second argument of
throw is used
as the return value of the
throw and the
catch are matched through the first
throw searches for a
catch whose first argument
eq to the one specified. Thus, in the above example, the
foo, and the
catch specifies the
same symbol, so that
catch is applicable. If there is more than
catch, the innermost one takes precedence.
All Lisp constructs between the
catch and the
including function calls, are exited automatically along with the
catch. When binding constructs such as
let or function
calls are exited in this way, the bindings are unbound, just as they are
when these constructs are exited normally (see section Local Variables).
Likewise, the buffer and position saved by
(see section Excursions) are restored, and so is the narrowing status
save-restriction and the window selection saved by
save-window-excursion (see section Window Configurations). Any
cleanups established with the
unwind-protect special form are
executed if the
unwind-protect is exited with a
throw need not appear lexically within the
that it jumps to. It can equally well be called from another function
called within the
catch. As long as the
throw takes place
chronologically after entry to the
catch, and chronologically
before exit from it, it has access to that
catch. This is why
throw can be used in commands such as
which throw back to the editor command loop (see section Recursive Editing).
Common Lisp note: most other versions of Lisp, including Common Lisp, have several ways of transferring control nonsequentially:
go, for example. Emacs Lisp has only
Special Form: catch tag body...
catch establishes a return point for the
throw function. The
return point is distinguished from other such return points by tag,
which may be any Lisp object. The argument tag is evaluated normally
before the return point is established.
With the return point in effect, the forms of the body are evaluated
in textual order. If the forms execute normally, without error or nonlocal
exit, the value of the last body form is returned from the
throw is done within body specifying the same value
catch exits immediately; the value it returns is
whatever was specified as the second argument of
Function: throw tag value
The purpose of
throw is to return from a return point previously
catch. The argument tag is used to choose
among the various existing return points; it must be
eq to the value
specified in the
catch. If multiple return points match tag,
the innermost one is used.
The argument value is used as the value to return from that
If no return point is in effect with tag tag, then a
error is signaled with data
One way to use
throw is to exit from a doubly
nested loop. (In most languages, this would be done with a "go to".)
Here we compute
(foo i j) for i and j
varying from 0 to 9:
(defun search-foo () (catch 'loop (let ((i 0)) (while (< i 10) (let ((j 0)) (while (< j 10) (if (foo i j) (throw 'loop (list i j))) (setq j (1+ j)))) (setq i (1+ i))))))
foo ever returns non-
nil, we stop immediately and return a
list of i and j. If
foo always returns
catch returns normally, and the value is
nil, since that
is the result of the
Here are two tricky examples, slightly different, showing two
return points at once. First, two return points with the same tag,
(defun catch2 (tag) (catch tag (throw 'hack 'yes))) => catch2 (catch 'hack (print (catch2 'hack)) 'no) -| yes => no
Since both return points have tags that match the
throw, it goes to
the inner one, the one established in
catch2 returns normally with value
yes, and this value is
printed. Finally the second body form in the outer
catch, which is
'no, is evaluated and returned from the outer
Now let's change the argument given to
(defun catch2 (tag) (catch tag (throw 'hack 'yes))) => catch2 (catch 'hack (print (catch2 'quux)) 'no) => yes
We still have two return points, but this time only the outer one has the
hack; the inner one has the tag
quux instead. Therefore,
throw returns the value
yes from the outer return point.
When Emacs Lisp attempts to evaluate a form that, for some reason, cannot be evaluated, it signals an error.
When an error is signaled, Emacs's default reaction is to print an error message and terminate execution of the current command. This is the right thing to do in most cases, such as if you type C-f at the end of the buffer.
In complicated programs, simple termination may not be what you want.
For example, the program may have made temporary changes in data
structures, or created temporary buffers which should be deleted before
the program is finished. In such cases, you would use
unwind-protect to establish cleanup expressions to be
evaluated in case of error. Occasionally, you may wish the program to
continue execution despite an error in a subroutine. In these cases,
you would use
condition-case to establish error handlers to
recover control in case of error.
Resist the temptation to use error handling to transfer control from
one part of the program to another; use
See section Explicit Nonlocal Exits:
Most errors are signaled "automatically" within Lisp primitives
which you call for other purposes, such as if you try to take the
CAR of an integer or move forward a character at the end of the
buffer; you can also signal errors explicitly with the functions
Quitting, which happens when the user types C-g, is not considered an error, but it handled almost like an error. See section Quitting.
Function: error format-string &rest args
This function signals an error with an error message constructed by
format (see section Conversion of Characters and Strings) to
format-string and args.
Typical uses of
error is shown in the following examples:
(error "You have committed an error. Try something else.") error--> You have committed an error. Try something else. (error "You have committed %d errors." 10) error--> You have committed 10 errors.
error works by calling
signal with two arguments: the
error, and a list containing the string returned by
If you want to use a user-supplied string as an error message verbatim,
don't just write
(error string). If string contains
`%', it will be interpreted as a format specifier, with undesirable
results. Instead, use
(error "%s" string).
Function: signal error-symbol data
This function signals an error named by error-symbol. The argument data is a list of additional Lisp objects relevant to the circumstances of the error.
The argument error-symbol must be an error symbol---a symbol
bearing a property
error-conditions whose value is a list of
condition names. This is how different sorts of errors are classified.
The number and significance of the objects in data depends on
error-symbol. For example, with a
there are two objects in the list: a predicate which describes the type
that was expected, and the object which failed to fit that type.
See section Error Symbols and Condition Names, for a description of error symbols.
Both error-symbol and data are available to any error
handlers which handle the error: a list
data) is constructed to become the value of the local variable
bound in the
condition-case form (see section Writing Code to Handle Errors). If
the error is not handled, both of them are used in printing the error
signal never returns (though in older Emacs versions
it could sometimes return).
(signal 'wrong-number-of-arguments '(x y)) error--> Wrong number of arguments: x, y (signal 'no-such-error '("My unknown error condition.")) error--> peculiar error: "My unknown error condition."
Common Lisp note: Emacs Lisp has nothing like the Common Lisp concept of continuable errors.
When an error is signaled, Emacs searches for an active handler
for the error. A handler is a specially marked place in the Lisp code
of the current function or any of the functions by which it was called.
If an applicable handler exists, its code is executed, and control
resumes following the handler. The handler executes in the environment
condition-case which established it; all functions called
condition-case have already been exited, and the
handler cannot return to them.
If no applicable handler is in effect in your program, the current command is terminated and control returns to the editor command loop, because the command loop has an implicit handler for all kinds of errors. The command loop's handler uses the error symbol and associated data to print an error message.
When an error is not handled explicitly, it may cause the Lisp debugger
to be called. The debugger is enabled if the variable
debug-on-error (see section Entering the Debugger on an Error) is non-
Unlike error handlers, the debugger runs in the environment of the
error, so that you can examine values of variables precisely as they
were at the time of the error.
The usual effect of signaling an error is to terminate the command that
is running and return immediately to the Emacs editor command loop.
You can arrange to trap errors occurring in a part of your program by
establishing an error handler with the special form
condition-case. A simple example looks like this:
(condition-case nil (delete-file filename) (error nil))
This deletes the file named filename, catching any error and
nil if an error occurs.
The second argument of
condition-case is called the
protected form. (In the example above, the protected form is a
delete-file.) The error handlers go into effect when
this form begins execution and are deactivated when this form returns.
They remain in effect for all the intervening time. In particular, they
are in effect during the execution of subroutines called by this form,
and their subroutines, and so on. This is a good thing, since, strictly
speaking, errors can be signaled only by Lisp primitives (including
error) called by the protected form, not by the
protected form itself.
The arguments after the protected form are handlers. Each handler
lists one or more condition names (which are symbols) to specify
which errors it will handle. The error symbol specified when an error
is signaled also defines a list of condition names. A handler applies
to an error if they have any condition names in common. In the example
above, there is one handler, and it specifies one condition name,
error, which covers all errors.
The search for an applicable handler checks all the established handlers
starting with the most recently established one. Thus, if two nested
condition-case forms try to handle the same error, the inner of
the two will actually handle it.
When an error is handled, control returns to the handler. Before this
happens, Emacs unbinds all variable bindings made by binding constructs
that are being exited and executes the cleanups of all
unwind-protect forms that are exited. Once control arrives at
the handler, the body of the handler is executed.
After execution of the handler body, execution continues by returning
condition-case form. Because the protected form is
exited completely before execution of the handler, the handler cannot
resume execution at the point of the error, nor can it examine variable
bindings that were made within the protected form. All it can do is
clean up and proceed.
condition-case is often used to trap errors that are
predictable, such as failure to open a file in a call to
insert-file-contents. It is also used to trap errors that are
totally unpredictable, such as when the program evaluates an expression
read from the user.
Error signaling and handling have some resemblance to
catch, but they are entirely separate facilities. An error
cannot be caught by a
catch, and a
throw cannot be handled
by an error handler (though using
throw when there is no suitable
catch signals an error which can be handled).
Special Form: condition-case var protected-form handlers...
This special form establishes the error handlers handlers around
the execution of protected-form. If protected-form executes
without error, the value it returns becomes the value of the
condition-case form; in this case, the
no effect. The
condition-case form makes a difference when an
error occurs during protected-form.
Each of the handlers is a list of the form
body...). conditions is an error condition name to be
handled, or a list of condition names; body is one or more Lisp
expressions to be executed when this handler handles an error. Here are
examples of handlers:
(error nil) (arith-error (message "Division by zero")) ((arith-error file-error) (message "Either division by zero or failure to open a file"))
Each error that occurs has an error symbol which describes what
kind of error it is. The
error-conditions property of this
symbol is a list of condition names (see section Error Symbols and Condition Names). Emacs
searches all the active
condition-case forms for a handler which
specifies one or more of these names; the innermost matching
condition-case handles the error. The handlers in this
condition-case are tested in the order in which they appear.
The body of the handler is then executed, and the
returns normally, using the value of the last form in the body as the
The argument var is a variable.
condition-case does not
bind this variable when executing the protected-form, only when it
handles an error. At that time, var is bound locally to a list of
(error-symbol . data), giving the
particulars of the error. The handler can refer to this list to decide
what to do. For example, if the error is for failure opening a file,
the file name is the second element of data---the third element of
If var is
nil, that means no variable is bound. Then the
error symbol and associated data are not made available to the handler.
Here is an example of using
condition-case to handle the error
that results from dividing by zero. The handler prints out a warning
message and returns a very large number.
(defun safe-divide (dividend divisor) (condition-case err ;; Protected form. (/ dividend divisor) ;; The handler. (arith-error ; Condition. (princ (format "Arithmetic error: %s" err)) 1000000))) => safe-divide (safe-divide 5 0) -| Arithmetic error: (arith-error) => 1000000
The handler specifies condition name
arith-error so that it will handle only division-by-zero errors. Other kinds of errors will not be handled, at least not by this
(safe-divide nil 3) error--> Wrong type argument: integer-or-marker-p, nil
Here is a
condition-case that catches all kinds of errors,
including those signaled with
(setq baz 34) => 34 (condition-case err (if (eq baz 35) t ;; This is a call to the function
error. (error "Rats! The variable %s was %s, not 35." 'baz baz)) ;; This is the handler; it is not a form. (error (princ (format "The error was: %s" err)) 2)) -| The error was: (error "Rats! The variable baz was 34, not 35.") => 2
When you signal an error, you specify an error symbol to specify the kind of error you have in mind. Each error has one and only one error symbol to categorize it. This is the finest classification of errors defined by the Lisp language.
These narrow classifications are grouped into a hierarchy of wider
classes called error conditions, identified by condition
names. The narrowest such classes belong to the error symbols
themselves: each error symbol is also a condition name. There are also
condition names for more extensive classes, up to the condition name
error which takes in all kinds of errors. Thus, each error has
one or more condition names:
error, the error symbol if that
is distinct from
error, and perhaps some intermediate
In order for a symbol to be usable as an error symbol, it must have an
error-conditions property which gives a list of condition names.
This list defines the conditions which this kind of error belongs to.
(The error symbol itself, and the symbol
error, should always be
members of this list.) Thus, the hierarchy of condition names is
defined by the
error-conditions properties of the error symbols.
In addition to the
error-conditions list, the error symbol
should have an
error-message property whose value is a string to
be printed when that error is signaled but not handled. If the
error-message property exists, but is not a string, the error
message `peculiar error' is used.
Here is how we define a new error symbol,
(put 'new-error 'error-conditions '(error my-own-errors new-error)) => (error my-own-errors new-error) (put 'new-error 'error-message "A new error") => "A new error"
This error has three condition names:
new-error, the narrowest
my-own-errors, which we imagine is a wider
error, which is the widest of all.
Naturally, Emacs will never signal a
new-error on its own; only
an explicit call to
signal (see section Errors) in your code can do
(signal 'new-error '(x y)) error--> A new error: x, y
This error can be handled through any of the three condition names.
This example handles
new-error and any other errors in the class
(condition-case foo (bar nil t) (my-own-errors nil))
The significant way that errors are classified is by their condition
names--the names used to match errors with handlers. An error symbol
serves only as a convenient way to specify the intended error message
and list of condition names. If
signal were given a list of
condition names rather than one error symbol, that would be cumbersome.
By contrast, using only error symbols without condition names would
seriously decrease the power of
condition-case. Condition names
make it possible to categorize errors at various levels of generality
when you write an error handler. Using error symbols alone would
eliminate all but the narrowest level of classification.
See section Standard Errors, for a list of all the standard error symbols and their conditions.
unwind-protect construct is essential whenever you
temporarily put a data structure in an inconsistent state; it permits
you to ensure the data are consistent in the event of an error or throw.
Special Form: unwind-protect body cleanup-forms...
unwind-protect executes the body with a guarantee that the
cleanup-forms will be evaluated if control leaves body, no
matter how that happens. The body may complete normally, or
throw out of the
unwind-protect, or cause an
error; in all cases, the cleanup-forms will be evaluated.
Only the body is actually protected by the
If any of the cleanup-forms themselves exit nonlocally (e.g., via
throw or an error), it is not guaranteed that the rest
of them will be executed. If the failure of one of the
cleanup-forms has the potential to cause trouble, then it should
be protected by another
unwind-protect around that form.
The number of currently active
unwind-protect forms counts,
together with the number of local variable bindings, against the limit
max-specpdl-size (see section Local Variables).
For example, here we make an invisible buffer for temporary use, and make sure to kill it before finishing:
(save-excursion (let ((buffer (get-buffer-create " *temp*"))) (set-buffer buffer) (unwind-protect body (kill-buffer buffer))))
You might think that we could just as well write
(current-buffer)) and dispense with the variable
However, the way shown above is safer, if body happens to get an
error after switching to a different buffer! (Alternatively, you could
save-excursion around the body, to ensure that the
temporary buffer becomes current in time to kill it.)
Here is an actual example taken from the file `ftp.el'. It creates
a process (see section Processes) to try to establish a connection to a remote
machine. As the function
ftp-login is highly susceptible to
numerous problems which the writer of the function cannot anticipate, it is
protected with a form that guarantees deletion of the process in the event
of failure. Otherwise, Emacs might fill up with useless subprocesses.
(let ((win nil)) (unwind-protect (progn (setq process (ftp-setup-buffer host file)) (if (setq win (ftp-login process host user password)) (message "Logged in") (error "Ftp login failed"))) (or win (and process (delete-process process)))))
This example actually has a small bug: if the user types C-g to
quit, and the quit happens immediately after the function
ftp-setup-buffer returns but before the variable
set, the process will not be killed. There is no easy way to fix this bug,
but at least it is very unlikely.
Go to the previous, next section.