2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990-1995, 1998-1999, 2001-2012 Free Software Foundation, Inc.
4 @c See the file elisp.texi for copying conditions.
5 @node Control Structures
6 @chapter Control Structures
7 @cindex special forms for control structures
8 @cindex control structures
10 A Lisp program consists of a set of @dfn{expressions}, or
11 @dfn{forms} (@pxref{Forms}). We control the order of execution of
12 these forms by enclosing them in @dfn{control structures}. Control
13 structures are special forms which control when, whether, or how many
14 times to execute the forms they contain.
17 The simplest order of execution is sequential execution: first form
18 @var{a}, then form @var{b}, and so on. This is what happens when you
19 write several forms in succession in the body of a function, or at top
20 level in a file of Lisp code---the forms are executed in the order
21 written. We call this @dfn{textual order}. For example, if a function
22 body consists of two forms @var{a} and @var{b}, evaluation of the
23 function evaluates first @var{a} and then @var{b}. The result of
24 evaluating @var{b} becomes the value of the function.
26 Explicit control structures make possible an order of execution other
29 Emacs Lisp provides several kinds of control structure, including
30 other varieties of sequencing, conditionals, iteration, and (controlled)
31 jumps---all discussed below. The built-in control structures are
32 special forms since their subforms are not necessarily evaluated or not
33 evaluated sequentially. You can use macros to define your own control
34 structure constructs (@pxref{Macros}).
37 * Sequencing:: Evaluation in textual order.
38 * Conditionals:: @code{if}, @code{cond}, @code{when}, @code{unless}.
39 * Combining Conditions:: @code{and}, @code{or}, @code{not}.
40 * Iteration:: @code{while} loops.
41 * Nonlocal Exits:: Jumping out of a sequence.
47 Evaluating forms in the order they appear is the most common way
48 control passes from one form to another. In some contexts, such as in a
49 function body, this happens automatically. Elsewhere you must use a
50 control structure construct to do this: @code{progn}, the simplest
51 control construct of Lisp.
53 A @code{progn} special form looks like this:
57 (progn @var{a} @var{b} @var{c} @dots{})
62 and it says to execute the forms @var{a}, @var{b}, @var{c}, and so on, in
63 that order. These forms are called the @dfn{body} of the @code{progn} form.
64 The value of the last form in the body becomes the value of the entire
65 @code{progn}. @code{(progn)} returns @code{nil}.
67 @cindex implicit @code{progn}
68 In the early days of Lisp, @code{progn} was the only way to execute
69 two or more forms in succession and use the value of the last of them.
70 But programmers found they often needed to use a @code{progn} in the
71 body of a function, where (at that time) only one form was allowed. So
72 the body of a function was made into an ``implicit @code{progn}'':
73 several forms are allowed just as in the body of an actual @code{progn}.
74 Many other control structures likewise contain an implicit @code{progn}.
75 As a result, @code{progn} is not used as much as it was many years ago.
76 It is needed now most often inside an @code{unwind-protect}, @code{and},
77 @code{or}, or in the @var{then}-part of an @code{if}.
79 @defspec progn forms@dots{}
80 This special form evaluates all of the @var{forms}, in textual
81 order, returning the result of the final form.
85 (progn (print "The first form")
86 (print "The second form")
87 (print "The third form"))
88 @print{} "The first form"
89 @print{} "The second form"
90 @print{} "The third form"
91 @result{} "The third form"
96 Two other constructs likewise evaluate a series of forms but return
99 @defspec prog1 form1 forms@dots{}
100 This special form evaluates @var{form1} and all of the @var{forms}, in
101 textual order, returning the result of @var{form1}.
105 (prog1 (print "The first form")
106 (print "The second form")
107 (print "The third form"))
108 @print{} "The first form"
109 @print{} "The second form"
110 @print{} "The third form"
111 @result{} "The first form"
115 Here is a way to remove the first element from a list in the variable
116 @code{x}, then return the value of that former element:
119 (prog1 (car x) (setq x (cdr x)))
123 @defspec prog2 form1 form2 forms@dots{}
124 This special form evaluates @var{form1}, @var{form2}, and all of the
125 following @var{forms}, in textual order, returning the result of
130 (prog2 (print "The first form")
131 (print "The second form")
132 (print "The third form"))
133 @print{} "The first form"
134 @print{} "The second form"
135 @print{} "The third form"
136 @result{} "The second form"
142 @section Conditionals
143 @cindex conditional evaluation
145 Conditional control structures choose among alternatives. Emacs Lisp
146 has four conditional forms: @code{if}, which is much the same as in
147 other languages; @code{when} and @code{unless}, which are variants of
148 @code{if}; and @code{cond}, which is a generalized case statement.
150 @defspec if condition then-form else-forms@dots{}
151 @code{if} chooses between the @var{then-form} and the @var{else-forms}
152 based on the value of @var{condition}. If the evaluated @var{condition} is
153 non-@code{nil}, @var{then-form} is evaluated and the result returned.
154 Otherwise, the @var{else-forms} are evaluated in textual order, and the
155 value of the last one is returned. (The @var{else} part of @code{if} is
156 an example of an implicit @code{progn}. @xref{Sequencing}.)
158 If @var{condition} has the value @code{nil}, and no @var{else-forms} are
159 given, @code{if} returns @code{nil}.
161 @code{if} is a special form because the branch that is not selected is
162 never evaluated---it is ignored. Thus, in this example,
163 @code{true} is not printed because @code{print} is never called:
175 @defmac when condition then-forms@dots{}
176 This is a variant of @code{if} where there are no @var{else-forms},
177 and possibly several @var{then-forms}. In particular,
180 (when @var{condition} @var{a} @var{b} @var{c})
184 is entirely equivalent to
187 (if @var{condition} (progn @var{a} @var{b} @var{c}) nil)
191 @defmac unless condition forms@dots{}
192 This is a variant of @code{if} where there is no @var{then-form}:
195 (unless @var{condition} @var{a} @var{b} @var{c})
199 is entirely equivalent to
202 (if @var{condition} nil
203 @var{a} @var{b} @var{c})
207 @defspec cond clause@dots{}
208 @code{cond} chooses among an arbitrary number of alternatives. Each
209 @var{clause} in the @code{cond} must be a list. The @sc{car} of this
210 list is the @var{condition}; the remaining elements, if any, the
211 @var{body-forms}. Thus, a clause looks like this:
214 (@var{condition} @var{body-forms}@dots{})
217 @code{cond} tries the clauses in textual order, by evaluating the
218 @var{condition} of each clause. If the value of @var{condition} is
219 non-@code{nil}, the clause ``succeeds''; then @code{cond} evaluates its
220 @var{body-forms}, and the value of the last of @var{body-forms} becomes
221 the value of the @code{cond}. The remaining clauses are ignored.
223 If the value of @var{condition} is @code{nil}, the clause ``fails'', so
224 the @code{cond} moves on to the following clause, trying its
227 If every @var{condition} evaluates to @code{nil}, so that every clause
228 fails, @code{cond} returns @code{nil}.
230 A clause may also look like this:
237 Then, if @var{condition} is non-@code{nil} when tested, the value of
238 @var{condition} becomes the value of the @code{cond} form.
240 The following example has four clauses, which test for the cases where
241 the value of @code{x} is a number, string, buffer and symbol,
246 (cond ((numberp x) x)
249 (setq temporary-hack x) ; @r{multiple body-forms}
250 (buffer-name x)) ; @r{in one clause}
251 ((symbolp x) (symbol-value x)))
255 Often we want to execute the last clause whenever none of the previous
256 clauses was successful. To do this, we use @code{t} as the
257 @var{condition} of the last clause, like this: @code{(t
258 @var{body-forms})}. The form @code{t} evaluates to @code{t}, which is
259 never @code{nil}, so this clause never fails, provided the @code{cond}
260 gets to it at all. For example:
265 (cond ((eq a 'hack) 'foo)
272 This @code{cond} expression returns @code{foo} if the value of @code{a}
273 is @code{hack}, and returns the string @code{"default"} otherwise.
276 Any conditional construct can be expressed with @code{cond} or with
277 @code{if}. Therefore, the choice between them is a matter of style.
282 (if @var{a} @var{b} @var{c})
284 (cond (@var{a} @var{b}) (t @var{c}))
289 * Pattern matching case statement::
292 @node Pattern matching case statement
293 @subsection Pattern matching case statement
295 @cindex pattern matching
297 To compare a particular value against various possible cases, the macro
298 @code{pcase} can come handy. It takes the following form:
301 (pcase @var{exp} @var{branch}1 @var{branch}2 @var{branch}3 @dots{})
304 where each @var{branch} takes the form @code{(@var{upattern}
305 @var{body-forms}@dots{})}.
307 It will first evaluate @var{exp} and then compare the value against each
308 @var{upattern} to see which @var{branch} to use, after which it will run the
309 corresponding @var{body-forms}. A common use case is to distinguish
310 between a few different constant values:
313 (pcase (get-return-code x)
314 (`success (message "Done!"))
315 (`would-block (message "Sorry, can't do it now"))
316 (`read-only (message "The shmliblick is read-only"))
317 (`access-denied (message "You do not have the needed rights"))
318 (code (message "Unknown return code %S" code)))
321 In the last clause, @code{code} is a variable that gets bound to the value that
322 was returned by @code{(get-return-code x)}.
324 To give a more complex example, a simple interpreter for a little
325 expression language could look like:
328 (defun evaluate (exp env)
330 (`(add ,x ,y) (+ (evaluate x env) (evaluate y env)))
331 (`(call ,fun ,arg) (funcall (evaluate fun) (evaluate arg env)))
332 (`(fn ,arg ,body) (lambda (val)
333 (evaluate body (cons (cons arg val) env))))
335 ((pred symbolp) (cdr (assq exp env)))
336 (_ (error "Unknown expression %S" exp))))
339 Where @code{`(add ,x ,y)} is a pattern that checks that @code{exp} is a three
340 element list starting with the symbol @code{add}, then extracts the second and
341 third elements and binds them to the variables @code{x} and @code{y}.
342 @code{(pred numberp)} is a pattern that simply checks that @code{exp}
343 is a number, and @code{_} is the catch-all pattern that matches anything.
345 There are two kinds of patterns involved in @code{pcase}, called
346 @emph{U-patterns} and @emph{Q-patterns}. The @var{upattern} mentioned above
347 are U-patterns and can take the following forms:
350 @item `@var{qpattern}
351 This is one of the most common form of patterns. The intention is to mimic the
352 backquote macro: this pattern matches those values that could have been built
353 by such a backquote expression. Since we're pattern matching rather than
354 building a value, the unquote does not indicate where to plug an expression,
355 but instead it lets one specify a U-pattern that should match the value at
358 More specifically, a Q-pattern can take the following forms:
360 @item (@var{qpattern1} . @var{qpattern2})
361 This pattern matches any cons cell whose @code{car} matches @var{QPATTERN1} and
362 whose @code{cdr} matches @var{PATTERN2}.
364 This pattern matches any atom @code{equal} to @var{atom}.
365 @item ,@var{upattern}
366 This pattern matches any object that matches the @var{upattern}.
370 A mere symbol in a U-pattern matches anything, and additionally let-binds this
371 symbol to the value that it matched, so that you can later refer to it, either
372 in the @var{body-forms} or also later in the pattern.
374 This so-called @emph{don't care} pattern matches anything, like the previous
375 one, but unless symbol patterns it does not bind any variable.
376 @item (pred @var{pred})
377 This pattern matches if the function @var{pred} returns non-@code{nil} when
378 called with the object being matched.
379 @item (or @var{upattern1} @var{upattern2}@dots{})
380 This pattern matches as soon as one of the argument patterns succeeds.
381 All argument patterns should let-bind the same variables.
382 @item (and @var{upattern1} @var{upattern2}@dots{})
383 This pattern matches only if all the argument patterns succeed.
384 @item (guard @var{exp})
385 This pattern ignores the object being examined and simply succeeds if @var{exp}
386 evaluates to non-@code{nil} and fails otherwise. It is typically used inside
387 an @code{and} pattern. For example, @code{(and x (guard (< x 10)))}
388 is a pattern which matches any number smaller than 10 and let-binds it to
389 the variable @code{x}.
392 @node Combining Conditions
393 @section Constructs for Combining Conditions
395 This section describes three constructs that are often used together
396 with @code{if} and @code{cond} to express complicated conditions. The
397 constructs @code{and} and @code{or} can also be used individually as
398 kinds of multiple conditional constructs.
401 This function tests for the falsehood of @var{condition}. It returns
402 @code{t} if @var{condition} is @code{nil}, and @code{nil} otherwise.
403 The function @code{not} is identical to @code{null}, and we recommend
404 using the name @code{null} if you are testing for an empty list.
407 @defspec and conditions@dots{}
408 The @code{and} special form tests whether all the @var{conditions} are
409 true. It works by evaluating the @var{conditions} one by one in the
412 If any of the @var{conditions} evaluates to @code{nil}, then the result
413 of the @code{and} must be @code{nil} regardless of the remaining
414 @var{conditions}; so @code{and} returns @code{nil} right away, ignoring
415 the remaining @var{conditions}.
417 If all the @var{conditions} turn out non-@code{nil}, then the value of
418 the last of them becomes the value of the @code{and} form. Just
419 @code{(and)}, with no @var{conditions}, returns @code{t}, appropriate
420 because all the @var{conditions} turned out non-@code{nil}. (Think
421 about it; which one did not?)
423 Here is an example. The first condition returns the integer 1, which is
424 not @code{nil}. Similarly, the second condition returns the integer 2,
425 which is not @code{nil}. The third condition is @code{nil}, so the
426 remaining condition is never evaluated.
430 (and (print 1) (print 2) nil (print 3))
437 Here is a more realistic example of using @code{and}:
441 (if (and (consp foo) (eq (car foo) 'x))
442 (message "foo is a list starting with x"))
447 Note that @code{(car foo)} is not executed if @code{(consp foo)} returns
448 @code{nil}, thus avoiding an error.
450 @code{and} expressions can also be written using either @code{if} or
451 @code{cond}. Here's how:
455 (and @var{arg1} @var{arg2} @var{arg3})
457 (if @var{arg1} (if @var{arg2} @var{arg3}))
459 (cond (@var{arg1} (cond (@var{arg2} @var{arg3}))))
464 @defspec or conditions@dots{}
465 The @code{or} special form tests whether at least one of the
466 @var{conditions} is true. It works by evaluating all the
467 @var{conditions} one by one in the order written.
469 If any of the @var{conditions} evaluates to a non-@code{nil} value, then
470 the result of the @code{or} must be non-@code{nil}; so @code{or} returns
471 right away, ignoring the remaining @var{conditions}. The value it
472 returns is the non-@code{nil} value of the condition just evaluated.
474 If all the @var{conditions} turn out @code{nil}, then the @code{or}
475 expression returns @code{nil}. Just @code{(or)}, with no
476 @var{conditions}, returns @code{nil}, appropriate because all the
477 @var{conditions} turned out @code{nil}. (Think about it; which one
480 For example, this expression tests whether @code{x} is either
481 @code{nil} or the integer zero:
484 (or (eq x nil) (eq x 0))
487 Like the @code{and} construct, @code{or} can be written in terms of
488 @code{cond}. For example:
492 (or @var{arg1} @var{arg2} @var{arg3})
500 You could almost write @code{or} in terms of @code{if}, but not quite:
504 (if @var{arg1} @var{arg1}
505 (if @var{arg2} @var{arg2}
511 This is not completely equivalent because it can evaluate @var{arg1} or
512 @var{arg2} twice. By contrast, @code{(or @var{arg1} @var{arg2}
513 @var{arg3})} never evaluates any argument more than once.
521 Iteration means executing part of a program repetitively. For
522 example, you might want to repeat some computation once for each element
523 of a list, or once for each integer from 0 to @var{n}. You can do this
524 in Emacs Lisp with the special form @code{while}:
526 @defspec while condition forms@dots{}
527 @code{while} first evaluates @var{condition}. If the result is
528 non-@code{nil}, it evaluates @var{forms} in textual order. Then it
529 reevaluates @var{condition}, and if the result is non-@code{nil}, it
530 evaluates @var{forms} again. This process repeats until @var{condition}
531 evaluates to @code{nil}.
533 There is no limit on the number of iterations that may occur. The loop
534 will continue until either @var{condition} evaluates to @code{nil} or
535 until an error or @code{throw} jumps out of it (@pxref{Nonlocal Exits}).
537 The value of a @code{while} form is always @code{nil}.
546 (princ (format "Iteration %d." num))
548 @print{} Iteration 0.
549 @print{} Iteration 1.
550 @print{} Iteration 2.
551 @print{} Iteration 3.
556 To write a ``repeat...until'' loop, which will execute something on each
557 iteration and then do the end-test, put the body followed by the
558 end-test in a @code{progn} as the first argument of @code{while}, as
565 (not (looking-at "^$"))))
570 This moves forward one line and continues moving by lines until it
571 reaches an empty line. It is peculiar in that the @code{while} has no
572 body, just the end test (which also does the real work of moving point).
575 The @code{dolist} and @code{dotimes} macros provide convenient ways to
576 write two common kinds of loops.
578 @defmac dolist (var list [result]) body@dots{}
579 This construct executes @var{body} once for each element of
580 @var{list}, binding the variable @var{var} locally to hold the current
581 element. Then it returns the value of evaluating @var{result}, or
582 @code{nil} if @var{result} is omitted. For example, here is how you
583 could use @code{dolist} to define the @code{reverse} function:
586 (defun reverse (list)
588 (dolist (elt list value)
589 (setq value (cons elt value)))))
593 @defmac dotimes (var count [result]) body@dots{}
594 This construct executes @var{body} once for each integer from 0
595 (inclusive) to @var{count} (exclusive), binding the variable @var{var}
596 to the integer for the current iteration. Then it returns the value
597 of evaluating @var{result}, or @code{nil} if @var{result} is omitted.
598 Here is an example of using @code{dotimes} to do something 100 times:
602 (insert "I will not obey absurd orders\n"))
607 @section Nonlocal Exits
608 @cindex nonlocal exits
610 A @dfn{nonlocal exit} is a transfer of control from one point in a
611 program to another remote point. Nonlocal exits can occur in Emacs Lisp
612 as a result of errors; you can also use them under explicit control.
613 Nonlocal exits unbind all variable bindings made by the constructs being
617 * Catch and Throw:: Nonlocal exits for the program's own purposes.
618 * Examples of Catch:: Showing how such nonlocal exits can be written.
619 * Errors:: How errors are signaled and handled.
620 * Cleanups:: Arranging to run a cleanup form if an error happens.
623 @node Catch and Throw
624 @subsection Explicit Nonlocal Exits: @code{catch} and @code{throw}
626 Most control constructs affect only the flow of control within the
627 construct itself. The function @code{throw} is the exception to this
628 rule of normal program execution: it performs a nonlocal exit on
629 request. (There are other exceptions, but they are for error handling
630 only.) @code{throw} is used inside a @code{catch}, and jumps back to
631 that @code{catch}. For example:
648 The @code{throw} form, if executed, transfers control straight back to
649 the corresponding @code{catch}, which returns immediately. The code
650 following the @code{throw} is not executed. The second argument of
651 @code{throw} is used as the return value of the @code{catch}.
653 The function @code{throw} finds the matching @code{catch} based on the
654 first argument: it searches for a @code{catch} whose first argument is
655 @code{eq} to the one specified in the @code{throw}. If there is more
656 than one applicable @code{catch}, the innermost one takes precedence.
657 Thus, in the above example, the @code{throw} specifies @code{foo}, and
658 the @code{catch} in @code{foo-outer} specifies the same symbol, so that
659 @code{catch} is the applicable one (assuming there is no other matching
660 @code{catch} in between).
662 Executing @code{throw} exits all Lisp constructs up to the matching
663 @code{catch}, including function calls. When binding constructs such
664 as @code{let} or function calls are exited in this way, the bindings
665 are unbound, just as they are when these constructs exit normally
666 (@pxref{Local Variables}). Likewise, @code{throw} restores the buffer
667 and position saved by @code{save-excursion} (@pxref{Excursions}), and
668 the narrowing status saved by @code{save-restriction}. It also runs
669 any cleanups established with the @code{unwind-protect} special form
670 when it exits that form (@pxref{Cleanups}).
672 The @code{throw} need not appear lexically within the @code{catch}
673 that it jumps to. It can equally well be called from another function
674 called within the @code{catch}. As long as the @code{throw} takes place
675 chronologically after entry to the @code{catch}, and chronologically
676 before exit from it, it has access to that @code{catch}. This is why
677 @code{throw} can be used in commands such as @code{exit-recursive-edit}
678 that throw back to the editor command loop (@pxref{Recursive Editing}).
680 @cindex CL note---only @code{throw} in Emacs
682 @b{Common Lisp note:} Most other versions of Lisp, including Common Lisp,
683 have several ways of transferring control nonsequentially: @code{return},
684 @code{return-from}, and @code{go}, for example. Emacs Lisp has only
685 @code{throw}. The @file{cl-lib} library provides versions of some of
686 these. @xref{Blocks and Exits,,,cl,Common Lisp Extensions}.
689 @defspec catch tag body@dots{}
690 @cindex tag on run time stack
691 @code{catch} establishes a return point for the @code{throw} function.
692 The return point is distinguished from other such return points by
693 @var{tag}, which may be any Lisp object except @code{nil}. The argument
694 @var{tag} is evaluated normally before the return point is established.
696 With the return point in effect, @code{catch} evaluates the forms of the
697 @var{body} in textual order. If the forms execute normally (without
698 error or nonlocal exit) the value of the last body form is returned from
701 If a @code{throw} is executed during the execution of @var{body},
702 specifying the same value @var{tag}, the @code{catch} form exits
703 immediately; the value it returns is whatever was specified as the
704 second argument of @code{throw}.
707 @defun throw tag value
708 The purpose of @code{throw} is to return from a return point previously
709 established with @code{catch}. The argument @var{tag} is used to choose
710 among the various existing return points; it must be @code{eq} to the value
711 specified in the @code{catch}. If multiple return points match @var{tag},
712 the innermost one is used.
714 The argument @var{value} is used as the value to return from that
718 If no return point is in effect with tag @var{tag}, then a @code{no-catch}
719 error is signaled with data @code{(@var{tag} @var{value})}.
722 @node Examples of Catch
723 @subsection Examples of @code{catch} and @code{throw}
725 One way to use @code{catch} and @code{throw} is to exit from a doubly
726 nested loop. (In most languages, this would be done with a ``goto''.)
727 Here we compute @code{(foo @var{i} @var{j})} for @var{i} and @var{j}
739 (throw 'loop (list i j)))
746 If @code{foo} ever returns non-@code{nil}, we stop immediately and return a
747 list of @var{i} and @var{j}. If @code{foo} always returns @code{nil}, the
748 @code{catch} returns normally, and the value is @code{nil}, since that
749 is the result of the @code{while}.
751 Here are two tricky examples, slightly different, showing two
752 return points at once. First, two return points with the same tag,
765 (print (catch2 'hack))
773 Since both return points have tags that match the @code{throw}, it goes to
774 the inner one, the one established in @code{catch2}. Therefore,
775 @code{catch2} returns normally with value @code{yes}, and this value is
776 printed. Finally the second body form in the outer @code{catch}, which is
777 @code{'no}, is evaluated and returned from the outer @code{catch}.
779 Now let's change the argument given to @code{catch2}:
784 (print (catch2 'quux))
791 We still have two return points, but this time only the outer one has
792 the tag @code{hack}; the inner one has the tag @code{quux} instead.
793 Therefore, @code{throw} makes the outer @code{catch} return the value
794 @code{yes}. The function @code{print} is never called, and the
795 body-form @code{'no} is never evaluated.
801 When Emacs Lisp attempts to evaluate a form that, for some reason,
802 cannot be evaluated, it @dfn{signals} an @dfn{error}.
804 When an error is signaled, Emacs's default reaction is to print an
805 error message and terminate execution of the current command. This is
806 the right thing to do in most cases, such as if you type @kbd{C-f} at
807 the end of the buffer.
809 In complicated programs, simple termination may not be what you want.
810 For example, the program may have made temporary changes in data
811 structures, or created temporary buffers that should be deleted before
812 the program is finished. In such cases, you would use
813 @code{unwind-protect} to establish @dfn{cleanup expressions} to be
814 evaluated in case of error. (@xref{Cleanups}.) Occasionally, you may
815 wish the program to continue execution despite an error in a subroutine.
816 In these cases, you would use @code{condition-case} to establish
817 @dfn{error handlers} to recover control in case of error.
819 Resist the temptation to use error handling to transfer control from
820 one part of the program to another; use @code{catch} and @code{throw}
821 instead. @xref{Catch and Throw}.
824 * Signaling Errors:: How to report an error.
825 * Processing of Errors:: What Emacs does when you report an error.
826 * Handling Errors:: How you can trap errors and continue execution.
827 * Error Symbols:: How errors are classified for trapping them.
830 @node Signaling Errors
831 @subsubsection How to Signal an Error
832 @cindex signaling errors
834 @dfn{Signaling} an error means beginning error processing. Error
835 processing normally aborts all or part of the running program and
836 returns to a point that is set up to handle the error
837 (@pxref{Processing of Errors}). Here we describe how to signal an
840 Most errors are signaled ``automatically'' within Lisp primitives
841 which you call for other purposes, such as if you try to take the
842 @sc{car} of an integer or move forward a character at the end of the
843 buffer. You can also signal errors explicitly with the functions
844 @code{error} and @code{signal}.
846 Quitting, which happens when the user types @kbd{C-g}, is not
847 considered an error, but it is handled almost like an error.
850 Every error specifies an error message, one way or another. The
851 message should state what is wrong (``File does not exist''), not how
852 things ought to be (``File must exist''). The convention in Emacs
853 Lisp is that error messages should start with a capital letter, but
854 should not end with any sort of punctuation.
856 @defun error format-string &rest args
857 This function signals an error with an error message constructed by
858 applying @code{format} (@pxref{Formatting Strings}) to
859 @var{format-string} and @var{args}.
861 These examples show typical uses of @code{error}:
865 (error "That is an error -- try something else")
866 @error{} That is an error -- try something else
870 (error "You have committed %d errors" 10)
871 @error{} You have committed 10 errors
875 @code{error} works by calling @code{signal} with two arguments: the
876 error symbol @code{error}, and a list containing the string returned by
879 @strong{Warning:} If you want to use your own string as an error message
880 verbatim, don't just write @code{(error @var{string})}. If @var{string}
881 contains @samp{%}, it will be interpreted as a format specifier, with
882 undesirable results. Instead, use @code{(error "%s" @var{string})}.
885 @defun signal error-symbol data
886 @anchor{Definition of signal}
887 This function signals an error named by @var{error-symbol}. The
888 argument @var{data} is a list of additional Lisp objects relevant to
889 the circumstances of the error.
891 The argument @var{error-symbol} must be an @dfn{error symbol}---a symbol
892 bearing a property @code{error-conditions} whose value is a list of
893 condition names. This is how Emacs Lisp classifies different sorts of
894 errors. @xref{Error Symbols}, for a description of error symbols,
895 error conditions and condition names.
897 If the error is not handled, the two arguments are used in printing
898 the error message. Normally, this error message is provided by the
899 @code{error-message} property of @var{error-symbol}. If @var{data} is
900 non-@code{nil}, this is followed by a colon and a comma separated list
901 of the unevaluated elements of @var{data}. For @code{error}, the
902 error message is the @sc{car} of @var{data} (that must be a string).
903 Subcategories of @code{file-error} are handled specially.
905 The number and significance of the objects in @var{data} depends on
906 @var{error-symbol}. For example, with a @code{wrong-type-argument} error,
907 there should be two objects in the list: a predicate that describes the type
908 that was expected, and the object that failed to fit that type.
910 Both @var{error-symbol} and @var{data} are available to any error
911 handlers that handle the error: @code{condition-case} binds a local
912 variable to a list of the form @code{(@var{error-symbol} .@:
913 @var{data})} (@pxref{Handling Errors}).
915 The function @code{signal} never returns.
916 @c (though in older Emacs versions it sometimes could).
920 (signal 'wrong-number-of-arguments '(x y))
921 @error{} Wrong number of arguments: x, y
925 (signal 'no-such-error '("My unknown error condition"))
926 @error{} peculiar error: "My unknown error condition"
931 @cindex user errors, signaling
932 @defun user-error format-string &rest args
933 This function behaves exactly like @code{error}, except that it uses
934 the error symbol @code{user-error} rather than @code{error}. As the
935 name suggests, this is intended to report errors on the part of the
936 user, rather than errors in the code itself. For example,
937 if you try to use the command @code{Info-history-back} (@kbd{l}) to
938 move back beyond the start of your Info browsing history, Emacs
939 signals a @code{user-error}. Such errors do not cause entry to the
940 debugger, even when @code{debug-on-error} is non-@code{nil}.
941 @xref{Error Debugging}.
944 @cindex CL note---no continuable errors
946 @b{Common Lisp note:} Emacs Lisp has nothing like the Common Lisp
947 concept of continuable errors.
950 @node Processing of Errors
951 @subsubsection How Emacs Processes Errors
953 When an error is signaled, @code{signal} searches for an active
954 @dfn{handler} for the error. A handler is a sequence of Lisp
955 expressions designated to be executed if an error happens in part of the
956 Lisp program. If the error has an applicable handler, the handler is
957 executed, and control resumes following the handler. The handler
958 executes in the environment of the @code{condition-case} that
959 established it; all functions called within that @code{condition-case}
960 have already been exited, and the handler cannot return to them.
962 If there is no applicable handler for the error, it terminates the
963 current command and returns control to the editor command loop. (The
964 command loop has an implicit handler for all kinds of errors.) The
965 command loop's handler uses the error symbol and associated data to
966 print an error message. You can use the variable
967 @code{command-error-function} to control how this is done:
969 @defvar command-error-function
970 This variable, if non-@code{nil}, specifies a function to use to
971 handle errors that return control to the Emacs command loop. The
972 function should take three arguments: @var{data}, a list of the same
973 form that @code{condition-case} would bind to its variable;
974 @var{context}, a string describing the situation in which the error
975 occurred, or (more often) @code{nil}; and @var{caller}, the Lisp
976 function which called the primitive that signaled the error.
979 @cindex @code{debug-on-error} use
980 An error that has no explicit handler may call the Lisp debugger. The
981 debugger is enabled if the variable @code{debug-on-error} (@pxref{Error
982 Debugging}) is non-@code{nil}. Unlike error handlers, the debugger runs
983 in the environment of the error, so that you can examine values of
984 variables precisely as they were at the time of the error.
986 @node Handling Errors
987 @subsubsection Writing Code to Handle Errors
988 @cindex error handler
989 @cindex handling errors
991 The usual effect of signaling an error is to terminate the command
992 that is running and return immediately to the Emacs editor command loop.
993 You can arrange to trap errors occurring in a part of your program by
994 establishing an error handler, with the special form
995 @code{condition-case}. A simple example looks like this:
1000 (delete-file filename)
1006 This deletes the file named @var{filename}, catching any error and
1007 returning @code{nil} if an error occurs. (You can use the macro
1008 @code{ignore-errors} for a simple case like this; see below.)
1010 The @code{condition-case} construct is often used to trap errors that
1011 are predictable, such as failure to open a file in a call to
1012 @code{insert-file-contents}. It is also used to trap errors that are
1013 totally unpredictable, such as when the program evaluates an expression
1016 The second argument of @code{condition-case} is called the
1017 @dfn{protected form}. (In the example above, the protected form is a
1018 call to @code{delete-file}.) The error handlers go into effect when
1019 this form begins execution and are deactivated when this form returns.
1020 They remain in effect for all the intervening time. In particular, they
1021 are in effect during the execution of functions called by this form, in
1022 their subroutines, and so on. This is a good thing, since, strictly
1023 speaking, errors can be signaled only by Lisp primitives (including
1024 @code{signal} and @code{error}) called by the protected form, not by the
1025 protected form itself.
1027 The arguments after the protected form are handlers. Each handler
1028 lists one or more @dfn{condition names} (which are symbols) to specify
1029 which errors it will handle. The error symbol specified when an error
1030 is signaled also defines a list of condition names. A handler applies
1031 to an error if they have any condition names in common. In the example
1032 above, there is one handler, and it specifies one condition name,
1033 @code{error}, which covers all errors.
1035 The search for an applicable handler checks all the established handlers
1036 starting with the most recently established one. Thus, if two nested
1037 @code{condition-case} forms offer to handle the same error, the inner of
1038 the two gets to handle it.
1040 If an error is handled by some @code{condition-case} form, this
1041 ordinarily prevents the debugger from being run, even if
1042 @code{debug-on-error} says this error should invoke the debugger.
1044 If you want to be able to debug errors that are caught by a
1045 @code{condition-case}, set the variable @code{debug-on-signal} to a
1046 non-@code{nil} value. You can also specify that a particular handler
1047 should let the debugger run first, by writing @code{debug} among the
1048 conditions, like this:
1053 (delete-file filename)
1054 ((debug error) nil))
1059 The effect of @code{debug} here is only to prevent
1060 @code{condition-case} from suppressing the call to the debugger. Any
1061 given error will invoke the debugger only if @code{debug-on-error} and
1062 the other usual filtering mechanisms say it should. @xref{Error Debugging}.
1064 @defmac condition-case-unless-debug var protected-form handlers@dots{}
1065 The macro @code{condition-case-unless-debug} provides another way to
1066 handle debugging of such forms. It behaves exactly like
1067 @code{condition-case}, unless the variable @code{debug-on-error} is
1068 non-@code{nil}, in which case it does not handle any errors at all.
1071 Once Emacs decides that a certain handler handles the error, it
1072 returns control to that handler. To do so, Emacs unbinds all variable
1073 bindings made by binding constructs that are being exited, and
1074 executes the cleanups of all @code{unwind-protect} forms that are
1075 being exited. Once control arrives at the handler, the body of the
1076 handler executes normally.
1078 After execution of the handler body, execution returns from the
1079 @code{condition-case} form. Because the protected form is exited
1080 completely before execution of the handler, the handler cannot resume
1081 execution at the point of the error, nor can it examine variable
1082 bindings that were made within the protected form. All it can do is
1083 clean up and proceed.
1085 Error signaling and handling have some resemblance to @code{throw} and
1086 @code{catch} (@pxref{Catch and Throw}), but they are entirely separate
1087 facilities. An error cannot be caught by a @code{catch}, and a
1088 @code{throw} cannot be handled by an error handler (though using
1089 @code{throw} when there is no suitable @code{catch} signals an error
1090 that can be handled).
1092 @defspec condition-case var protected-form handlers@dots{}
1093 This special form establishes the error handlers @var{handlers} around
1094 the execution of @var{protected-form}. If @var{protected-form} executes
1095 without error, the value it returns becomes the value of the
1096 @code{condition-case} form; in this case, the @code{condition-case} has
1097 no effect. The @code{condition-case} form makes a difference when an
1098 error occurs during @var{protected-form}.
1100 Each of the @var{handlers} is a list of the form @code{(@var{conditions}
1101 @var{body}@dots{})}. Here @var{conditions} is an error condition name
1102 to be handled, or a list of condition names (which can include @code{debug}
1103 to allow the debugger to run before the handler); @var{body} is one or more
1104 Lisp expressions to be executed when this handler handles an error.
1105 Here are examples of handlers:
1111 (arith-error (message "Division by zero"))
1113 ((arith-error file-error)
1115 "Either division by zero or failure to open a file"))
1119 Each error that occurs has an @dfn{error symbol} that describes what
1120 kind of error it is. The @code{error-conditions} property of this
1121 symbol is a list of condition names (@pxref{Error Symbols}). Emacs
1122 searches all the active @code{condition-case} forms for a handler that
1123 specifies one or more of these condition names; the innermost matching
1124 @code{condition-case} handles the error. Within this
1125 @code{condition-case}, the first applicable handler handles the error.
1127 After executing the body of the handler, the @code{condition-case}
1128 returns normally, using the value of the last form in the handler body
1129 as the overall value.
1131 @cindex error description
1132 The argument @var{var} is a variable. @code{condition-case} does not
1133 bind this variable when executing the @var{protected-form}, only when it
1134 handles an error. At that time, it binds @var{var} locally to an
1135 @dfn{error description}, which is a list giving the particulars of the
1136 error. The error description has the form @code{(@var{error-symbol}
1137 . @var{data})}. The handler can refer to this list to decide what to
1138 do. For example, if the error is for failure opening a file, the file
1139 name is the second element of @var{data}---the third element of the
1142 If @var{var} is @code{nil}, that means no variable is bound. Then the
1143 error symbol and associated data are not available to the handler.
1145 @cindex rethrow a signal
1146 Sometimes it is necessary to re-throw a signal caught by
1147 @code{condition-case}, for some outer-level handler to catch. Here's
1151 (signal (car err) (cdr err))
1155 where @code{err} is the error description variable, the first argument
1156 to @code{condition-case} whose error condition you want to re-throw.
1157 @xref{Definition of signal}.
1160 @defun error-message-string error-descriptor
1161 This function returns the error message string for a given error
1162 descriptor. It is useful if you want to handle an error by printing the
1163 usual error message for that error. @xref{Definition of signal}.
1166 @cindex @code{arith-error} example
1167 Here is an example of using @code{condition-case} to handle the error
1168 that results from dividing by zero. The handler displays the error
1169 message (but without a beep), then returns a very large number.
1173 (defun safe-divide (dividend divisor)
1175 ;; @r{Protected form.}
1176 (/ dividend divisor)
1180 (arith-error ; @r{Condition.}
1181 ;; @r{Display the usual message for this error.}
1182 (message "%s" (error-message-string err))
1184 @result{} safe-divide
1189 @print{} Arithmetic error: (arith-error)
1195 The handler specifies condition name @code{arith-error} so that it
1196 will handle only division-by-zero errors. Other kinds of errors will
1197 not be handled (by this @code{condition-case}). Thus:
1202 @error{} Wrong type argument: number-or-marker-p, nil
1206 Here is a @code{condition-case} that catches all kinds of errors,
1207 including those from @code{error}:
1219 ;; @r{This is a call to the function @code{error}.}
1220 (error "Rats! The variable %s was %s, not 35" 'baz baz))
1221 ;; @r{This is the handler; it is not a form.}
1222 (error (princ (format "The error was: %s" err))
1224 @print{} The error was: (error "Rats! The variable baz was 34, not 35")
1229 @defmac ignore-errors body@dots{}
1230 This construct executes @var{body}, ignoring any errors that occur
1231 during its execution. If the execution is without error,
1232 @code{ignore-errors} returns the value of the last form in @var{body};
1233 otherwise, it returns @code{nil}.
1235 Here's the example at the beginning of this subsection rewritten using
1236 @code{ignore-errors}:
1241 (delete-file filename))
1246 @defmac with-demoted-errors body@dots{}
1247 This macro is like a milder version of @code{ignore-errors}. Rather
1248 than suppressing errors altogether, it converts them into messages.
1249 Use this form around code that is not expected to signal errors, but
1250 should be robust if one does occur. Note that this macro uses
1251 @code{condition-case-unless-debug} rather than @code{condition-case}.
1255 @subsubsection Error Symbols and Condition Names
1256 @cindex error symbol
1258 @cindex condition name
1259 @cindex user-defined error
1260 @kindex error-conditions
1262 When you signal an error, you specify an @dfn{error symbol} to specify
1263 the kind of error you have in mind. Each error has one and only one
1264 error symbol to categorize it. This is the finest classification of
1265 errors defined by the Emacs Lisp language.
1267 These narrow classifications are grouped into a hierarchy of wider
1268 classes called @dfn{error conditions}, identified by @dfn{condition
1269 names}. The narrowest such classes belong to the error symbols
1270 themselves: each error symbol is also a condition name. There are also
1271 condition names for more extensive classes, up to the condition name
1272 @code{error} which takes in all kinds of errors (but not @code{quit}).
1273 Thus, each error has one or more condition names: @code{error}, the
1274 error symbol if that is distinct from @code{error}, and perhaps some
1275 intermediate classifications.
1277 In order for a symbol to be an error symbol, it must have an
1278 @code{error-conditions} property which gives a list of condition names.
1279 This list defines the conditions that this kind of error belongs to.
1280 (The error symbol itself, and the symbol @code{error}, should always be
1281 members of this list.) Thus, the hierarchy of condition names is
1282 defined by the @code{error-conditions} properties of the error symbols.
1283 Because quitting is not considered an error, the value of the
1284 @code{error-conditions} property of @code{quit} is just @code{(quit)}.
1286 @cindex peculiar error
1287 In addition to the @code{error-conditions} list, the error symbol
1288 should have an @code{error-message} property whose value is a string to
1289 be printed when that error is signaled but not handled. If the
1290 error symbol has no @code{error-message} property or if the
1291 @code{error-message} property exists, but is not a string, the error
1292 message @samp{peculiar error} is used. @xref{Definition of signal}.
1294 Here is how we define a new error symbol, @code{new-error}:
1300 '(error my-own-errors new-error))
1301 @result{} (error my-own-errors new-error)
1304 (put 'new-error 'error-message "A new error")
1305 @result{} "A new error"
1310 This error has three condition names: @code{new-error}, the narrowest
1311 classification; @code{my-own-errors}, which we imagine is a wider
1312 classification; and @code{error}, which is the widest of all.
1314 The error string should start with a capital letter but it should
1315 not end with a period. This is for consistency with the rest of Emacs.
1317 Naturally, Emacs will never signal @code{new-error} on its own; only
1318 an explicit call to @code{signal} (@pxref{Definition of signal}) in
1319 your code can do this:
1323 (signal 'new-error '(x y))
1324 @error{} A new error: x, y
1328 This error can be handled through any of the three condition names.
1329 This example handles @code{new-error} and any other errors in the class
1330 @code{my-own-errors}:
1336 (my-own-errors nil))
1340 The significant way that errors are classified is by their condition
1341 names---the names used to match errors with handlers. An error symbol
1342 serves only as a convenient way to specify the intended error message
1343 and list of condition names. It would be cumbersome to give
1344 @code{signal} a list of condition names rather than one error symbol.
1346 By contrast, using only error symbols without condition names would
1347 seriously decrease the power of @code{condition-case}. Condition names
1348 make it possible to categorize errors at various levels of generality
1349 when you write an error handler. Using error symbols alone would
1350 eliminate all but the narrowest level of classification.
1352 @xref{Standard Errors}, for a list of the main error symbols
1353 and their conditions.
1356 @subsection Cleaning Up from Nonlocal Exits
1358 The @code{unwind-protect} construct is essential whenever you
1359 temporarily put a data structure in an inconsistent state; it permits
1360 you to make the data consistent again in the event of an error or
1361 throw. (Another more specific cleanup construct that is used only for
1362 changes in buffer contents is the atomic change group; @ref{Atomic
1365 @defspec unwind-protect body-form cleanup-forms@dots{}
1366 @cindex cleanup forms
1367 @cindex protected forms
1368 @cindex error cleanup
1370 @code{unwind-protect} executes @var{body-form} with a guarantee that
1371 the @var{cleanup-forms} will be evaluated if control leaves
1372 @var{body-form}, no matter how that happens. @var{body-form} may
1373 complete normally, or execute a @code{throw} out of the
1374 @code{unwind-protect}, or cause an error; in all cases, the
1375 @var{cleanup-forms} will be evaluated.
1377 If @var{body-form} finishes normally, @code{unwind-protect} returns the
1378 value of @var{body-form}, after it evaluates the @var{cleanup-forms}.
1379 If @var{body-form} does not finish, @code{unwind-protect} does not
1380 return any value in the normal sense.
1382 Only @var{body-form} is protected by the @code{unwind-protect}. If any
1383 of the @var{cleanup-forms} themselves exits nonlocally (via a
1384 @code{throw} or an error), @code{unwind-protect} is @emph{not}
1385 guaranteed to evaluate the rest of them. If the failure of one of the
1386 @var{cleanup-forms} has the potential to cause trouble, then protect
1387 it with another @code{unwind-protect} around that form.
1389 The number of currently active @code{unwind-protect} forms counts,
1390 together with the number of local variable bindings, against the limit
1391 @code{max-specpdl-size} (@pxref{Definition of max-specpdl-size,, Local
1395 For example, here we make an invisible buffer for temporary use, and
1396 make sure to kill it before finishing:
1400 (let ((buffer (get-buffer-create " *temp*")))
1401 (with-current-buffer buffer
1404 (kill-buffer buffer))))
1409 You might think that we could just as well write @code{(kill-buffer
1410 (current-buffer))} and dispense with the variable @code{buffer}.
1411 However, the way shown above is safer, if @var{body-form} happens to
1412 get an error after switching to a different buffer! (Alternatively,
1413 you could write a @code{save-current-buffer} around @var{body-form},
1414 to ensure that the temporary buffer becomes current again in time to
1417 Emacs includes a standard macro called @code{with-temp-buffer} which
1418 expands into more or less the code shown above (@pxref{Definition of
1419 with-temp-buffer,, Current Buffer}). Several of the macros defined in
1420 this manual use @code{unwind-protect} in this way.
1423 Here is an actual example derived from an FTP package. It creates a
1424 process (@pxref{Processes}) to try to establish a connection to a remote
1425 machine. As the function @code{ftp-login} is highly susceptible to
1426 numerous problems that the writer of the function cannot anticipate, it
1427 is protected with a form that guarantees deletion of the process in the
1428 event of failure. Otherwise, Emacs might fill up with useless
1436 (setq process (ftp-setup-buffer host file))
1437 (if (setq win (ftp-login process host user password))
1438 (message "Logged in")
1439 (error "Ftp login failed")))
1440 (or win (and process (delete-process process)))))
1444 This example has a small bug: if the user types @kbd{C-g} to
1445 quit, and the quit happens immediately after the function
1446 @code{ftp-setup-buffer} returns but before the variable @code{process} is
1447 set, the process will not be killed. There is no easy way to fix this bug,
1448 but at least it is very unlikely.