emacs-lisp/package.el (package-activate-1): Reload package after upgrade
[emacs.git] / doc / lispref / control.texi
blob5cf6368db52d5ac5548cd76be9c9cb2f8879a0b9
1 @c -*-texinfo-*-
2 @c This is part of the GNU Emacs Lisp Reference Manual.
3 @c Copyright (C) 1990-1995, 1998-1999, 2001-2014 Free Software
4 @c Foundation, Inc.
5 @c See the file elisp.texi for copying conditions.
6 @node Control Structures
7 @chapter Control Structures
8 @cindex special forms for control structures
9 @cindex control structures
11   A Lisp program consists of a set of @dfn{expressions}, or
12 @dfn{forms} (@pxref{Forms}).  We control the order of execution of
13 these forms by enclosing them in @dfn{control structures}.  Control
14 structures are special forms which control when, whether, or how many
15 times to execute the forms they contain.
17 @cindex textual order
18   The simplest order of execution is sequential execution: first form
19 @var{a}, then form @var{b}, and so on.  This is what happens when you
20 write several forms in succession in the body of a function, or at top
21 level in a file of Lisp code---the forms are executed in the order
22 written.  We call this @dfn{textual order}.  For example, if a function
23 body consists of two forms @var{a} and @var{b}, evaluation of the
24 function evaluates first @var{a} and then @var{b}.  The result of
25 evaluating @var{b} becomes the value of the function.
27   Explicit control structures make possible an order of execution other
28 than sequential.
30   Emacs Lisp provides several kinds of control structure, including
31 other varieties of sequencing, conditionals, iteration, and (controlled)
32 jumps---all discussed below.  The built-in control structures are
33 special forms since their subforms are not necessarily evaluated or not
34 evaluated sequentially.  You can use macros to define your own control
35 structure constructs (@pxref{Macros}).
37 @menu
38 * Sequencing::             Evaluation in textual order.
39 * Conditionals::           @code{if}, @code{cond}, @code{when}, @code{unless}.
40 * Combining Conditions::   @code{and}, @code{or}, @code{not}.
41 * Iteration::              @code{while} loops.
42 * Nonlocal Exits::         Jumping out of a sequence.
43 @end menu
45 @node Sequencing
46 @section Sequencing
48   Evaluating forms in the order they appear is the most common way
49 control passes from one form to another.  In some contexts, such as in a
50 function body, this happens automatically.  Elsewhere you must use a
51 control structure construct to do this: @code{progn}, the simplest
52 control construct of Lisp.
54   A @code{progn} special form looks like this:
56 @example
57 @group
58 (progn @var{a} @var{b} @var{c} @dots{})
59 @end group
60 @end example
62 @noindent
63 and it says to execute the forms @var{a}, @var{b}, @var{c}, and so on, in
64 that order.  These forms are called the @dfn{body} of the @code{progn} form.
65 The value of the last form in the body becomes the value of the entire
66 @code{progn}.  @code{(progn)} returns @code{nil}.
68 @cindex implicit @code{progn}
69   In the early days of Lisp, @code{progn} was the only way to execute
70 two or more forms in succession and use the value of the last of them.
71 But programmers found they often needed to use a @code{progn} in the
72 body of a function, where (at that time) only one form was allowed.  So
73 the body of a function was made into an ``implicit @code{progn}'':
74 several forms are allowed just as in the body of an actual @code{progn}.
75 Many other control structures likewise contain an implicit @code{progn}.
76 As a result, @code{progn} is not used as much as it was many years ago.
77 It is needed now most often inside an @code{unwind-protect}, @code{and},
78 @code{or}, or in the @var{then}-part of an @code{if}.
80 @defspec progn forms@dots{}
81 This special form evaluates all of the @var{forms}, in textual
82 order, returning the result of the final form.
84 @example
85 @group
86 (progn (print "The first form")
87        (print "The second form")
88        (print "The third form"))
89      @print{} "The first form"
90      @print{} "The second form"
91      @print{} "The third form"
92 @result{} "The third form"
93 @end group
94 @end example
95 @end defspec
97   Two other constructs likewise evaluate a series of forms but return
98 different values:
100 @defspec prog1 form1 forms@dots{}
101 This special form evaluates @var{form1} and all of the @var{forms}, in
102 textual order, returning the result of @var{form1}.
104 @example
105 @group
106 (prog1 (print "The first form")
107        (print "The second form")
108        (print "The third form"))
109      @print{} "The first form"
110      @print{} "The second form"
111      @print{} "The third form"
112 @result{} "The first form"
113 @end group
114 @end example
116 Here is a way to remove the first element from a list in the variable
117 @code{x}, then return the value of that former element:
119 @example
120 (prog1 (car x) (setq x (cdr x)))
121 @end example
122 @end defspec
124 @defspec prog2 form1 form2 forms@dots{}
125 This special form evaluates @var{form1}, @var{form2}, and all of the
126 following @var{forms}, in textual order, returning the result of
127 @var{form2}.
129 @example
130 @group
131 (prog2 (print "The first form")
132        (print "The second form")
133        (print "The third form"))
134      @print{} "The first form"
135      @print{} "The second form"
136      @print{} "The third form"
137 @result{} "The second form"
138 @end group
139 @end example
140 @end defspec
142 @node Conditionals
143 @section Conditionals
144 @cindex conditional evaluation
146   Conditional control structures choose among alternatives.  Emacs Lisp
147 has four conditional forms: @code{if}, which is much the same as in
148 other languages; @code{when} and @code{unless}, which are variants of
149 @code{if}; and @code{cond}, which is a generalized case statement.
151 @defspec if condition then-form else-forms@dots{}
152 @code{if} chooses between the @var{then-form} and the @var{else-forms}
153 based on the value of @var{condition}.  If the evaluated @var{condition} is
154 non-@code{nil}, @var{then-form} is evaluated and the result returned.
155 Otherwise, the @var{else-forms} are evaluated in textual order, and the
156 value of the last one is returned.  (The @var{else} part of @code{if} is
157 an example of an implicit @code{progn}.  @xref{Sequencing}.)
159 If @var{condition} has the value @code{nil}, and no @var{else-forms} are
160 given, @code{if} returns @code{nil}.
162 @code{if} is a special form because the branch that is not selected is
163 never evaluated---it is ignored.  Thus, in this example,
164 @code{true} is not printed because @code{print} is never called:
166 @example
167 @group
168 (if nil
169     (print 'true)
170   'very-false)
171 @result{} very-false
172 @end group
173 @end example
174 @end defspec
176 @defmac when condition then-forms@dots{}
177 This is a variant of @code{if} where there are no @var{else-forms},
178 and possibly several @var{then-forms}.  In particular,
180 @example
181 (when @var{condition} @var{a} @var{b} @var{c})
182 @end example
184 @noindent
185 is entirely equivalent to
187 @example
188 (if @var{condition} (progn @var{a} @var{b} @var{c}) nil)
189 @end example
190 @end defmac
192 @defmac unless condition forms@dots{}
193 This is a variant of @code{if} where there is no @var{then-form}:
195 @example
196 (unless @var{condition} @var{a} @var{b} @var{c})
197 @end example
199 @noindent
200 is entirely equivalent to
202 @example
203 (if @var{condition} nil
204    @var{a} @var{b} @var{c})
205 @end example
206 @end defmac
208 @defspec cond clause@dots{}
209 @code{cond} chooses among an arbitrary number of alternatives.  Each
210 @var{clause} in the @code{cond} must be a list.  The @sc{car} of this
211 list is the @var{condition}; the remaining elements, if any, the
212 @var{body-forms}.  Thus, a clause looks like this:
214 @example
215 (@var{condition} @var{body-forms}@dots{})
216 @end example
218 @code{cond} tries the clauses in textual order, by evaluating the
219 @var{condition} of each clause.  If the value of @var{condition} is
220 non-@code{nil}, the clause ``succeeds''; then @code{cond} evaluates its
221 @var{body-forms}, and returns the value of the last of @var{body-forms}.
222 Any remaining clauses are ignored.
224 If the value of @var{condition} is @code{nil}, the clause ``fails'', so
225 the @code{cond} moves on to the following clause, trying its @var{condition}.
227 A clause may also look like this:
229 @example
230 (@var{condition})
231 @end example
233 @noindent
234 Then, if @var{condition} is non-@code{nil} when tested, the @code{cond}
235 form returns the value of @var{condition}.
237 If every @var{condition} evaluates to @code{nil}, so that every clause
238 fails, @code{cond} returns @code{nil}.
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,
242 respectively:
244 @example
245 @group
246 (cond ((numberp x) x)
247       ((stringp x) x)
248       ((bufferp x)
249        (setq temporary-hack x) ; @r{multiple body-forms}
250        (buffer-name x))        ; @r{in one clause}
251       ((symbolp x) (symbol-value x)))
252 @end group
253 @end example
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:
262 @example
263 @group
264 (setq a 5)
265 (cond ((eq a 'hack) 'foo)
266       (t "default"))
267 @result{} "default"
268 @end group
269 @end example
271 @noindent
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.
274 @end defspec
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.
278 For example:
280 @example
281 @group
282 (if @var{a} @var{b} @var{c})
283 @equiv{}
284 (cond (@var{a} @var{b}) (t @var{c}))
285 @end group
286 @end example
288 @menu
289 * Pattern matching case statement::
290 @end menu
292 @node Pattern matching case statement
293 @subsection Pattern matching case statement
294 @cindex pcase
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:
300 @example
301 (pcase @var{exp} @var{branch}1 @var{branch}2 @var{branch}3 @dots{})
302 @end example
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:
312 @example
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)))
319 @end example
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 (note that this example requires
326 lexical binding):
328 @example
329 (defun evaluate (exp env)
330   (pcase exp
331     (`(add ,x ,y)       (+ (evaluate x env) (evaluate y env)))
332     (`(call ,fun ,arg)  (funcall (evaluate fun env) (evaluate arg env)))
333     (`(fn ,arg ,body)   (lambda (val)
334                           (evaluate body (cons (cons arg val) env))))
335     ((pred numberp)     exp)
336     ((pred symbolp)     (cdr (assq exp env)))
337     (_                  (error "Unknown expression %S" exp))))
338 @end example
340 Where @code{`(add ,x ,y)} is a pattern that checks that @code{exp} is a three
341 element list starting with the symbol @code{add}, then extracts the second and
342 third elements and binds them to the variables @code{x} and @code{y}.
343 @code{(pred numberp)} is a pattern that simply checks that @code{exp}
344 is a number, and @code{_} is the catch-all pattern that matches anything.
346 Here are some sample programs including their evaluation results:
348 @example
349 (evaluate '(add 1 2) nil)                 ;=> 3
350 (evaluate '(add x y) '((x . 1) (y . 2)))  ;=> 3
351 (evaluate '(call (fn x (add 1 x)) 2) nil) ;=> 3
352 (evaluate '(sub 1 2) nil)                 ;=> error
353 @end example
355 There are two kinds of patterns involved in @code{pcase}, called
356 @emph{U-patterns} and @emph{Q-patterns}.  The @var{upattern} mentioned above
357 are U-patterns and can take the following forms:
359 @table @code
360 @item `@var{qpattern}
361 This is one of the most common form of patterns.  The intention is to mimic the
362 backquote macro: this pattern matches those values that could have been built
363 by such a backquote expression.  Since we're pattern matching rather than
364 building a value, the unquote does not indicate where to plug an expression,
365 but instead it lets one specify a U-pattern that should match the value at
366 that location.
368 More specifically, a Q-pattern can take the following forms:
369 @table @code
370 @item (@var{qpattern1} . @var{qpattern2})
371 This pattern matches any cons cell whose @code{car} matches @var{QPATTERN1} and
372 whose @code{cdr} matches @var{PATTERN2}.
373 @item [@var{qpattern1 qpattern2..qpatternm}]
374 This pattern matches a vector of length @code{M} whose 0..(M-1)th
375 elements match @var{QPATTERN1}, @var{QPATTERN2}..@var{QPATTERNm},
376 respectively.
377 @item @var{atom}
378 This pattern matches any atom @code{equal} to @var{atom}.
379 @item ,@var{upattern}
380 This pattern matches any object that matches the @var{upattern}.
381 @end table
383 @item @var{symbol}
384 A mere symbol in a U-pattern matches anything, and additionally let-binds this
385 symbol to the value that it matched, so that you can later refer to it, either
386 in the @var{body-forms} or also later in the pattern.
387 @item _
388 This so-called @emph{don't care} pattern matches anything, like the previous
389 one, but unlike symbol patterns it does not bind any variable.
390 @item (pred @var{pred})
391 This pattern matches if the function @var{pred} returns non-@code{nil} when
392 called with the object being matched.
393 @item (or @var{upattern1} @var{upattern2}@dots{})
394 This pattern matches as soon as one of the argument patterns succeeds.
395 All argument patterns should let-bind the same variables.
396 @item (and @var{upattern1} @var{upattern2}@dots{})
397 This pattern matches only if all the argument patterns succeed.
398 @item (guard @var{exp})
399 This pattern ignores the object being examined and simply succeeds if @var{exp}
400 evaluates to non-@code{nil} and fails otherwise.  It is typically used inside
401 an @code{and} pattern.  For example, @code{(and x (guard (< x 10)))}
402 is a pattern which matches any number smaller than 10 and let-binds it to
403 the variable @code{x}.
404 @end table
406 @node Combining Conditions
407 @section Constructs for Combining Conditions
409   This section describes three constructs that are often used together
410 with @code{if} and @code{cond} to express complicated conditions.  The
411 constructs @code{and} and @code{or} can also be used individually as
412 kinds of multiple conditional constructs.
414 @defun not condition
415 This function tests for the falsehood of @var{condition}.  It returns
416 @code{t} if @var{condition} is @code{nil}, and @code{nil} otherwise.
417 The function @code{not} is identical to @code{null}, and we recommend
418 using the name @code{null} if you are testing for an empty list.
419 @end defun
421 @defspec and conditions@dots{}
422 The @code{and} special form tests whether all the @var{conditions} are
423 true.  It works by evaluating the @var{conditions} one by one in the
424 order written.
426 If any of the @var{conditions} evaluates to @code{nil}, then the result
427 of the @code{and} must be @code{nil} regardless of the remaining
428 @var{conditions}; so @code{and} returns @code{nil} right away, ignoring
429 the remaining @var{conditions}.
431 If all the @var{conditions} turn out non-@code{nil}, then the value of
432 the last of them becomes the value of the @code{and} form.  Just
433 @code{(and)}, with no @var{conditions}, returns @code{t}, appropriate
434 because all the @var{conditions} turned out non-@code{nil}.  (Think
435 about it; which one did not?)
437 Here is an example.  The first condition returns the integer 1, which is
438 not @code{nil}.  Similarly, the second condition returns the integer 2,
439 which is not @code{nil}.  The third condition is @code{nil}, so the
440 remaining condition is never evaluated.
442 @example
443 @group
444 (and (print 1) (print 2) nil (print 3))
445      @print{} 1
446      @print{} 2
447 @result{} nil
448 @end group
449 @end example
451 Here is a more realistic example of using @code{and}:
453 @example
454 @group
455 (if (and (consp foo) (eq (car foo) 'x))
456     (message "foo is a list starting with x"))
457 @end group
458 @end example
460 @noindent
461 Note that @code{(car foo)} is not executed if @code{(consp foo)} returns
462 @code{nil}, thus avoiding an error.
464 @code{and} expressions can also be written using either @code{if} or
465 @code{cond}.  Here's how:
467 @example
468 @group
469 (and @var{arg1} @var{arg2} @var{arg3})
470 @equiv{}
471 (if @var{arg1} (if @var{arg2} @var{arg3}))
472 @equiv{}
473 (cond (@var{arg1} (cond (@var{arg2} @var{arg3}))))
474 @end group
475 @end example
476 @end defspec
478 @defspec or conditions@dots{}
479 The @code{or} special form tests whether at least one of the
480 @var{conditions} is true.  It works by evaluating all the
481 @var{conditions} one by one in the order written.
483 If any of the @var{conditions} evaluates to a non-@code{nil} value, then
484 the result of the @code{or} must be non-@code{nil}; so @code{or} returns
485 right away, ignoring the remaining @var{conditions}.  The value it
486 returns is the non-@code{nil} value of the condition just evaluated.
488 If all the @var{conditions} turn out @code{nil}, then the @code{or}
489 expression returns @code{nil}.  Just @code{(or)}, with no
490 @var{conditions}, returns @code{nil}, appropriate because all the
491 @var{conditions} turned out @code{nil}.  (Think about it; which one
492 did not?)
494 For example, this expression tests whether @code{x} is either
495 @code{nil} or the integer zero:
497 @example
498 (or (eq x nil) (eq x 0))
499 @end example
501 Like the @code{and} construct, @code{or} can be written in terms of
502 @code{cond}.  For example:
504 @example
505 @group
506 (or @var{arg1} @var{arg2} @var{arg3})
507 @equiv{}
508 (cond (@var{arg1})
509       (@var{arg2})
510       (@var{arg3}))
511 @end group
512 @end example
514 You could almost write @code{or} in terms of @code{if}, but not quite:
516 @example
517 @group
518 (if @var{arg1} @var{arg1}
519   (if @var{arg2} @var{arg2}
520     @var{arg3}))
521 @end group
522 @end example
524 @noindent
525 This is not completely equivalent because it can evaluate @var{arg1} or
526 @var{arg2} twice.  By contrast, @code{(or @var{arg1} @var{arg2}
527 @var{arg3})} never evaluates any argument more than once.
528 @end defspec
530 @node Iteration
531 @section Iteration
532 @cindex iteration
533 @cindex recursion
535   Iteration means executing part of a program repetitively.  For
536 example, you might want to repeat some computation once for each element
537 of a list, or once for each integer from 0 to @var{n}.  You can do this
538 in Emacs Lisp with the special form @code{while}:
540 @defspec while condition forms@dots{}
541 @code{while} first evaluates @var{condition}.  If the result is
542 non-@code{nil}, it evaluates @var{forms} in textual order.  Then it
543 reevaluates @var{condition}, and if the result is non-@code{nil}, it
544 evaluates @var{forms} again.  This process repeats until @var{condition}
545 evaluates to @code{nil}.
547 There is no limit on the number of iterations that may occur.  The loop
548 will continue until either @var{condition} evaluates to @code{nil} or
549 until an error or @code{throw} jumps out of it (@pxref{Nonlocal Exits}).
551 The value of a @code{while} form is always @code{nil}.
553 @example
554 @group
555 (setq num 0)
556      @result{} 0
557 @end group
558 @group
559 (while (< num 4)
560   (princ (format "Iteration %d." num))
561   (setq num (1+ num)))
562      @print{} Iteration 0.
563      @print{} Iteration 1.
564      @print{} Iteration 2.
565      @print{} Iteration 3.
566      @result{} nil
567 @end group
568 @end example
570 To write a ``repeat...until'' loop, which will execute something on each
571 iteration and then do the end-test, put the body followed by the
572 end-test in a @code{progn} as the first argument of @code{while}, as
573 shown here:
575 @example
576 @group
577 (while (progn
578          (forward-line 1)
579          (not (looking-at "^$"))))
580 @end group
581 @end example
583 @noindent
584 This moves forward one line and continues moving by lines until it
585 reaches an empty line.  It is peculiar in that the @code{while} has no
586 body, just the end test (which also does the real work of moving point).
587 @end defspec
589   The @code{dolist} and @code{dotimes} macros provide convenient ways to
590 write two common kinds of loops.
592 @defmac dolist (var list [result]) body@dots{}
593 This construct executes @var{body} once for each element of
594 @var{list}, binding the variable @var{var} locally to hold the current
595 element.  Then it returns the value of evaluating @var{result}, or
596 @code{nil} if @var{result} is omitted.  For example, here is how you
597 could use @code{dolist} to define the @code{reverse} function:
599 @example
600 (defun reverse (list)
601   (let (value)
602     (dolist (elt list value)
603       (setq value (cons elt value)))))
604 @end example
605 @end defmac
607 @defmac dotimes (var count [result]) body@dots{}
608 This construct executes @var{body} once for each integer from 0
609 (inclusive) to @var{count} (exclusive), binding the variable @var{var}
610 to the integer for the current iteration.  Then it returns the value
611 of evaluating @var{result}, or @code{nil} if @var{result} is omitted.
612 Here is an example of using @code{dotimes} to do something 100 times:
614 @example
615 (dotimes (i 100)
616   (insert "I will not obey absurd orders\n"))
617 @end example
618 @end defmac
620 @node Nonlocal Exits
621 @section Nonlocal Exits
622 @cindex nonlocal exits
624   A @dfn{nonlocal exit} is a transfer of control from one point in a
625 program to another remote point.  Nonlocal exits can occur in Emacs Lisp
626 as a result of errors; you can also use them under explicit control.
627 Nonlocal exits unbind all variable bindings made by the constructs being
628 exited.
630 @menu
631 * Catch and Throw::     Nonlocal exits for the program's own purposes.
632 * Examples of Catch::   Showing how such nonlocal exits can be written.
633 * Errors::              How errors are signaled and handled.
634 * Cleanups::            Arranging to run a cleanup form if an error happens.
635 @end menu
637 @node Catch and Throw
638 @subsection Explicit Nonlocal Exits: @code{catch} and @code{throw}
640   Most control constructs affect only the flow of control within the
641 construct itself.  The function @code{throw} is the exception to this
642 rule of normal program execution: it performs a nonlocal exit on
643 request.  (There are other exceptions, but they are for error handling
644 only.)  @code{throw} is used inside a @code{catch}, and jumps back to
645 that @code{catch}.  For example:
647 @example
648 @group
649 (defun foo-outer ()
650   (catch 'foo
651     (foo-inner)))
653 (defun foo-inner ()
654   @dots{}
655   (if x
656       (throw 'foo t))
657   @dots{})
658 @end group
659 @end example
661 @noindent
662 The @code{throw} form, if executed, transfers control straight back to
663 the corresponding @code{catch}, which returns immediately.  The code
664 following the @code{throw} is not executed.  The second argument of
665 @code{throw} is used as the return value of the @code{catch}.
667   The function @code{throw} finds the matching @code{catch} based on the
668 first argument: it searches for a @code{catch} whose first argument is
669 @code{eq} to the one specified in the @code{throw}.  If there is more
670 than one applicable @code{catch}, the innermost one takes precedence.
671 Thus, in the above example, the @code{throw} specifies @code{foo}, and
672 the @code{catch} in @code{foo-outer} specifies the same symbol, so that
673 @code{catch} is the applicable one (assuming there is no other matching
674 @code{catch} in between).
676   Executing @code{throw} exits all Lisp constructs up to the matching
677 @code{catch}, including function calls.  When binding constructs such
678 as @code{let} or function calls are exited in this way, the bindings
679 are unbound, just as they are when these constructs exit normally
680 (@pxref{Local Variables}).  Likewise, @code{throw} restores the buffer
681 and position saved by @code{save-excursion} (@pxref{Excursions}), and
682 the narrowing status saved by @code{save-restriction}.  It also runs
683 any cleanups established with the @code{unwind-protect} special form
684 when it exits that form (@pxref{Cleanups}).
686   The @code{throw} need not appear lexically within the @code{catch}
687 that it jumps to.  It can equally well be called from another function
688 called within the @code{catch}.  As long as the @code{throw} takes place
689 chronologically after entry to the @code{catch}, and chronologically
690 before exit from it, it has access to that @code{catch}.  This is why
691 @code{throw} can be used in commands such as @code{exit-recursive-edit}
692 that throw back to the editor command loop (@pxref{Recursive Editing}).
694 @cindex CL note---only @code{throw} in Emacs
695 @quotation
696 @b{Common Lisp note:} Most other versions of Lisp, including Common Lisp,
697 have several ways of transferring control nonsequentially: @code{return},
698 @code{return-from}, and @code{go}, for example.  Emacs Lisp has only
699 @code{throw}.  The @file{cl-lib} library provides versions of some of
700 these.  @xref{Blocks and Exits,,,cl,Common Lisp Extensions}.
701 @end quotation
703 @defspec catch tag body@dots{}
704 @cindex tag on run time stack
705 @code{catch} establishes a return point for the @code{throw} function.
706 The return point is distinguished from other such return points by
707 @var{tag}, which may be any Lisp object except @code{nil}.  The argument
708 @var{tag} is evaluated normally before the return point is established.
710 With the return point in effect, @code{catch} evaluates the forms of the
711 @var{body} in textual order.  If the forms execute normally (without
712 error or nonlocal exit) the value of the last body form is returned from
713 the @code{catch}.
715 If a @code{throw} is executed during the execution of @var{body},
716 specifying the same value @var{tag}, the @code{catch} form exits
717 immediately; the value it returns is whatever was specified as the
718 second argument of @code{throw}.
719 @end defspec
721 @defun throw tag value
722 The purpose of @code{throw} is to return from a return point previously
723 established with @code{catch}.  The argument @var{tag} is used to choose
724 among the various existing return points; it must be @code{eq} to the value
725 specified in the @code{catch}.  If multiple return points match @var{tag},
726 the innermost one is used.
728 The argument @var{value} is used as the value to return from that
729 @code{catch}.
731 @kindex no-catch
732 If no return point is in effect with tag @var{tag}, then a @code{no-catch}
733 error is signaled with data @code{(@var{tag} @var{value})}.
734 @end defun
736 @node Examples of Catch
737 @subsection Examples of @code{catch} and @code{throw}
739   One way to use @code{catch} and @code{throw} is to exit from a doubly
740 nested loop.  (In most languages, this would be done with a ``goto''.)
741 Here we compute @code{(foo @var{i} @var{j})} for @var{i} and @var{j}
742 varying from 0 to 9:
744 @example
745 @group
746 (defun search-foo ()
747   (catch 'loop
748     (let ((i 0))
749       (while (< i 10)
750         (let ((j 0))
751           (while (< j 10)
752             (if (foo i j)
753                 (throw 'loop (list i j)))
754             (setq j (1+ j))))
755         (setq i (1+ i))))))
756 @end group
757 @end example
759 @noindent
760 If @code{foo} ever returns non-@code{nil}, we stop immediately and return a
761 list of @var{i} and @var{j}.  If @code{foo} always returns @code{nil}, the
762 @code{catch} returns normally, and the value is @code{nil}, since that
763 is the result of the @code{while}.
765   Here are two tricky examples, slightly different, showing two
766 return points at once.  First, two return points with the same tag,
767 @code{hack}:
769 @example
770 @group
771 (defun catch2 (tag)
772   (catch tag
773     (throw 'hack 'yes)))
774 @result{} catch2
775 @end group
777 @group
778 (catch 'hack
779   (print (catch2 'hack))
780   'no)
781 @print{} yes
782 @result{} no
783 @end group
784 @end example
786 @noindent
787 Since both return points have tags that match the @code{throw}, it goes to
788 the inner one, the one established in @code{catch2}.  Therefore,
789 @code{catch2} returns normally with value @code{yes}, and this value is
790 printed.  Finally the second body form in the outer @code{catch}, which is
791 @code{'no}, is evaluated and returned from the outer @code{catch}.
793   Now let's change the argument given to @code{catch2}:
795 @example
796 @group
797 (catch 'hack
798   (print (catch2 'quux))
799   'no)
800 @result{} yes
801 @end group
802 @end example
804 @noindent
805 We still have two return points, but this time only the outer one has
806 the tag @code{hack}; the inner one has the tag @code{quux} instead.
807 Therefore, @code{throw} makes the outer @code{catch} return the value
808 @code{yes}.  The function @code{print} is never called, and the
809 body-form @code{'no} is never evaluated.
811 @node Errors
812 @subsection Errors
813 @cindex errors
815   When Emacs Lisp attempts to evaluate a form that, for some reason,
816 cannot be evaluated, it @dfn{signals} an @dfn{error}.
818   When an error is signaled, Emacs's default reaction is to print an
819 error message and terminate execution of the current command.  This is
820 the right thing to do in most cases, such as if you type @kbd{C-f} at
821 the end of the buffer.
823   In complicated programs, simple termination may not be what you want.
824 For example, the program may have made temporary changes in data
825 structures, or created temporary buffers that should be deleted before
826 the program is finished.  In such cases, you would use
827 @code{unwind-protect} to establish @dfn{cleanup expressions} to be
828 evaluated in case of error.  (@xref{Cleanups}.)  Occasionally, you may
829 wish the program to continue execution despite an error in a subroutine.
830 In these cases, you would use @code{condition-case} to establish
831 @dfn{error handlers} to recover control in case of error.
833   Resist the temptation to use error handling to transfer control from
834 one part of the program to another; use @code{catch} and @code{throw}
835 instead.  @xref{Catch and Throw}.
837 @menu
838 * Signaling Errors::      How to report an error.
839 * Processing of Errors::  What Emacs does when you report an error.
840 * Handling Errors::       How you can trap errors and continue execution.
841 * Error Symbols::         How errors are classified for trapping them.
842 @end menu
844 @node Signaling Errors
845 @subsubsection How to Signal an Error
846 @cindex signaling errors
848    @dfn{Signaling} an error means beginning error processing.  Error
849 processing normally aborts all or part of the running program and
850 returns to a point that is set up to handle the error
851 (@pxref{Processing of Errors}).  Here we describe how to signal an
852 error.
854   Most errors are signaled ``automatically'' within Lisp primitives
855 which you call for other purposes, such as if you try to take the
856 @sc{car} of an integer or move forward a character at the end of the
857 buffer.  You can also signal errors explicitly with the functions
858 @code{error} and @code{signal}.
860   Quitting, which happens when the user types @kbd{C-g}, is not
861 considered an error, but it is handled almost like an error.
862 @xref{Quitting}.
864   Every error specifies an error message, one way or another.  The
865 message should state what is wrong (``File does not exist''), not how
866 things ought to be (``File must exist'').  The convention in Emacs
867 Lisp is that error messages should start with a capital letter, but
868 should not end with any sort of punctuation.
870 @defun error format-string &rest args
871 This function signals an error with an error message constructed by
872 applying @code{format} (@pxref{Formatting Strings}) to
873 @var{format-string} and @var{args}.
875 These examples show typical uses of @code{error}:
877 @example
878 @group
879 (error "That is an error -- try something else")
880      @error{} That is an error -- try something else
881 @end group
883 @group
884 (error "You have committed %d errors" 10)
885      @error{} You have committed 10 errors
886 @end group
887 @end example
889 @code{error} works by calling @code{signal} with two arguments: the
890 error symbol @code{error}, and a list containing the string returned by
891 @code{format}.
893 @strong{Warning:} If you want to use your own string as an error message
894 verbatim, don't just write @code{(error @var{string})}.  If @var{string}
895 contains @samp{%}, it will be interpreted as a format specifier, with
896 undesirable results.  Instead, use @code{(error "%s" @var{string})}.
897 @end defun
899 @defun signal error-symbol data
900 @anchor{Definition of signal}
901 This function signals an error named by @var{error-symbol}.  The
902 argument @var{data} is a list of additional Lisp objects relevant to
903 the circumstances of the error.
905 The argument @var{error-symbol} must be an @dfn{error symbol}---a symbol
906 defined with @code{define-error}.  This is how Emacs Lisp classifies different
907 sorts of errors. @xref{Error Symbols}, for a description of error symbols,
908 error conditions and condition names.
910 If the error is not handled, the two arguments are used in printing
911 the error message.  Normally, this error message is provided by the
912 @code{error-message} property of @var{error-symbol}.  If @var{data} is
913 non-@code{nil}, this is followed by a colon and a comma separated list
914 of the unevaluated elements of @var{data}.  For @code{error}, the
915 error message is the @sc{car} of @var{data} (that must be a string).
916 Subcategories of @code{file-error} are handled specially.
918 The number and significance of the objects in @var{data} depends on
919 @var{error-symbol}.  For example, with a @code{wrong-type-argument} error,
920 there should be two objects in the list: a predicate that describes the type
921 that was expected, and the object that failed to fit that type.
923 Both @var{error-symbol} and @var{data} are available to any error
924 handlers that handle the error: @code{condition-case} binds a local
925 variable to a list of the form @code{(@var{error-symbol} .@:
926 @var{data})} (@pxref{Handling Errors}).
928 The function @code{signal} never returns.
929 @c (though in older Emacs versions it sometimes could).
931 @example
932 @group
933 (signal 'wrong-number-of-arguments '(x y))
934      @error{} Wrong number of arguments: x, y
935 @end group
937 @group
938 (signal 'no-such-error '("My unknown error condition"))
939      @error{} peculiar error: "My unknown error condition"
940 @end group
941 @end example
942 @end defun
944 @cindex user errors, signaling
945 @defun user-error format-string &rest args
946 This function behaves exactly like @code{error}, except that it uses
947 the error symbol @code{user-error} rather than @code{error}.  As the
948 name suggests, this is intended to report errors on the part of the
949 user, rather than errors in the code itself.  For example,
950 if you try to use the command @code{Info-history-back} (@kbd{l}) to
951 move back beyond the start of your Info browsing history, Emacs
952 signals a @code{user-error}.  Such errors do not cause entry to the
953 debugger, even when @code{debug-on-error} is non-@code{nil}.
954 @xref{Error Debugging}.
955 @end defun
957 @cindex CL note---no continuable errors
958 @quotation
959 @b{Common Lisp note:} Emacs Lisp has nothing like the Common Lisp
960 concept of continuable errors.
961 @end quotation
963 @node Processing of Errors
964 @subsubsection How Emacs Processes Errors
966 When an error is signaled, @code{signal} searches for an active
967 @dfn{handler} for the error.  A handler is a sequence of Lisp
968 expressions designated to be executed if an error happens in part of the
969 Lisp program.  If the error has an applicable handler, the handler is
970 executed, and control resumes following the handler.  The handler
971 executes in the environment of the @code{condition-case} that
972 established it; all functions called within that @code{condition-case}
973 have already been exited, and the handler cannot return to them.
975 If there is no applicable handler for the error, it terminates the
976 current command and returns control to the editor command loop.  (The
977 command loop has an implicit handler for all kinds of errors.)  The
978 command loop's handler uses the error symbol and associated data to
979 print an error message.  You can use the variable
980 @code{command-error-function} to control how this is done:
982 @defvar command-error-function
983 This variable, if non-@code{nil}, specifies a function to use to
984 handle errors that return control to the Emacs command loop.  The
985 function should take three arguments: @var{data}, a list of the same
986 form that @code{condition-case} would bind to its variable;
987 @var{context}, a string describing the situation in which the error
988 occurred, or (more often) @code{nil}; and @var{caller}, the Lisp
989 function which called the primitive that signaled the error.
990 @end defvar
992 @cindex @code{debug-on-error} use
993 An error that has no explicit handler may call the Lisp debugger.  The
994 debugger is enabled if the variable @code{debug-on-error} (@pxref{Error
995 Debugging}) is non-@code{nil}.  Unlike error handlers, the debugger runs
996 in the environment of the error, so that you can examine values of
997 variables precisely as they were at the time of the error.
999 @node Handling Errors
1000 @subsubsection Writing Code to Handle Errors
1001 @cindex error handler
1002 @cindex handling errors
1004   The usual effect of signaling an error is to terminate the command
1005 that is running and return immediately to the Emacs editor command loop.
1006 You can arrange to trap errors occurring in a part of your program by
1007 establishing an error handler, with the special form
1008 @code{condition-case}.  A simple example looks like this:
1010 @example
1011 @group
1012 (condition-case nil
1013     (delete-file filename)
1014   (error nil))
1015 @end group
1016 @end example
1018 @noindent
1019 This deletes the file named @var{filename}, catching any error and
1020 returning @code{nil} if an error occurs.  (You can use the macro
1021 @code{ignore-errors} for a simple case like this; see below.)
1023   The @code{condition-case} construct is often used to trap errors that
1024 are predictable, such as failure to open a file in a call to
1025 @code{insert-file-contents}.  It is also used to trap errors that are
1026 totally unpredictable, such as when the program evaluates an expression
1027 read from the user.
1029   The second argument of @code{condition-case} is called the
1030 @dfn{protected form}.  (In the example above, the protected form is a
1031 call to @code{delete-file}.)  The error handlers go into effect when
1032 this form begins execution and are deactivated when this form returns.
1033 They remain in effect for all the intervening time.  In particular, they
1034 are in effect during the execution of functions called by this form, in
1035 their subroutines, and so on.  This is a good thing, since, strictly
1036 speaking, errors can be signaled only by Lisp primitives (including
1037 @code{signal} and @code{error}) called by the protected form, not by the
1038 protected form itself.
1040   The arguments after the protected form are handlers.  Each handler
1041 lists one or more @dfn{condition names} (which are symbols) to specify
1042 which errors it will handle.  The error symbol specified when an error
1043 is signaled also defines a list of condition names.  A handler applies
1044 to an error if they have any condition names in common.  In the example
1045 above, there is one handler, and it specifies one condition name,
1046 @code{error}, which covers all errors.
1048   The search for an applicable handler checks all the established handlers
1049 starting with the most recently established one.  Thus, if two nested
1050 @code{condition-case} forms offer to handle the same error, the inner of
1051 the two gets to handle it.
1053   If an error is handled by some @code{condition-case} form, this
1054 ordinarily prevents the debugger from being run, even if
1055 @code{debug-on-error} says this error should invoke the debugger.
1057   If you want to be able to debug errors that are caught by a
1058 @code{condition-case}, set the variable @code{debug-on-signal} to a
1059 non-@code{nil} value.  You can also specify that a particular handler
1060 should let the debugger run first, by writing @code{debug} among the
1061 conditions, like this:
1063 @example
1064 @group
1065 (condition-case nil
1066     (delete-file filename)
1067   ((debug error) nil))
1068 @end group
1069 @end example
1071 @noindent
1072 The effect of @code{debug} here is only to prevent
1073 @code{condition-case} from suppressing the call to the debugger.  Any
1074 given error will invoke the debugger only if @code{debug-on-error} and
1075 the other usual filtering mechanisms say it should.  @xref{Error Debugging}.
1077 @defmac condition-case-unless-debug var protected-form handlers@dots{}
1078 The macro @code{condition-case-unless-debug} provides another way to
1079 handle debugging of such forms.  It behaves exactly like
1080 @code{condition-case}, unless the variable @code{debug-on-error} is
1081 non-@code{nil}, in which case it does not handle any errors at all.
1082 @end defmac
1084   Once Emacs decides that a certain handler handles the error, it
1085 returns control to that handler.  To do so, Emacs unbinds all variable
1086 bindings made by binding constructs that are being exited, and
1087 executes the cleanups of all @code{unwind-protect} forms that are
1088 being exited.  Once control arrives at the handler, the body of the
1089 handler executes normally.
1091   After execution of the handler body, execution returns from the
1092 @code{condition-case} form.  Because the protected form is exited
1093 completely before execution of the handler, the handler cannot resume
1094 execution at the point of the error, nor can it examine variable
1095 bindings that were made within the protected form.  All it can do is
1096 clean up and proceed.
1098   Error signaling and handling have some resemblance to @code{throw} and
1099 @code{catch} (@pxref{Catch and Throw}), but they are entirely separate
1100 facilities.  An error cannot be caught by a @code{catch}, and a
1101 @code{throw} cannot be handled by an error handler (though using
1102 @code{throw} when there is no suitable @code{catch} signals an error
1103 that can be handled).
1105 @defspec condition-case var protected-form handlers@dots{}
1106 This special form establishes the error handlers @var{handlers} around
1107 the execution of @var{protected-form}.  If @var{protected-form} executes
1108 without error, the value it returns becomes the value of the
1109 @code{condition-case} form; in this case, the @code{condition-case} has
1110 no effect.  The @code{condition-case} form makes a difference when an
1111 error occurs during @var{protected-form}.
1113 Each of the @var{handlers} is a list of the form @code{(@var{conditions}
1114 @var{body}@dots{})}.  Here @var{conditions} is an error condition name
1115 to be handled, or a list of condition names (which can include @code{debug}
1116 to allow the debugger to run before the handler); @var{body} is one or more
1117 Lisp expressions to be executed when this handler handles an error.
1118 Here are examples of handlers:
1120 @example
1121 @group
1122 (error nil)
1124 (arith-error (message "Division by zero"))
1126 ((arith-error file-error)
1127  (message
1128   "Either division by zero or failure to open a file"))
1129 @end group
1130 @end example
1132 Each error that occurs has an @dfn{error symbol} that describes what
1133 kind of error it is, and which describes also a list of condition names
1134 (@pxref{Error Symbols}).  Emacs
1135 searches all the active @code{condition-case} forms for a handler that
1136 specifies one or more of these condition names; the innermost matching
1137 @code{condition-case} handles the error.  Within this
1138 @code{condition-case}, the first applicable handler handles the error.
1140 After executing the body of the handler, the @code{condition-case}
1141 returns normally, using the value of the last form in the handler body
1142 as the overall value.
1144 @cindex error description
1145 The argument @var{var} is a variable.  @code{condition-case} does not
1146 bind this variable when executing the @var{protected-form}, only when it
1147 handles an error.  At that time, it binds @var{var} locally to an
1148 @dfn{error description}, which is a list giving the particulars of the
1149 error.  The error description has the form @code{(@var{error-symbol}
1150 . @var{data})}.  The handler can refer to this list to decide what to
1151 do.  For example, if the error is for failure opening a file, the file
1152 name is the second element of @var{data}---the third element of the
1153 error description.
1155 If @var{var} is @code{nil}, that means no variable is bound.  Then the
1156 error symbol and associated data are not available to the handler.
1158 @cindex rethrow a signal
1159 Sometimes it is necessary to re-throw a signal caught by
1160 @code{condition-case}, for some outer-level handler to catch.  Here's
1161 how to do that:
1163 @example
1164   (signal (car err) (cdr err))
1165 @end example
1167 @noindent
1168 where @code{err} is the error description variable, the first argument
1169 to @code{condition-case} whose error condition you want to re-throw.
1170 @xref{Definition of signal}.
1171 @end defspec
1173 @defun error-message-string error-descriptor
1174 This function returns the error message string for a given error
1175 descriptor.  It is useful if you want to handle an error by printing the
1176 usual error message for that error.  @xref{Definition of signal}.
1177 @end defun
1179 @cindex @code{arith-error} example
1180 Here is an example of using @code{condition-case} to handle the error
1181 that results from dividing by zero.  The handler displays the error
1182 message (but without a beep), then returns a very large number.
1184 @example
1185 @group
1186 (defun safe-divide (dividend divisor)
1187   (condition-case err
1188       ;; @r{Protected form.}
1189       (/ dividend divisor)
1190 @end group
1191 @group
1192     ;; @r{The handler.}
1193     (arith-error                        ; @r{Condition.}
1194      ;; @r{Display the usual message for this error.}
1195      (message "%s" (error-message-string err))
1196      1000000)))
1197 @result{} safe-divide
1198 @end group
1200 @group
1201 (safe-divide 5 0)
1202      @print{} Arithmetic error: (arith-error)
1203 @result{} 1000000
1204 @end group
1205 @end example
1207 @noindent
1208 The handler specifies condition name @code{arith-error} so that it
1209 will handle only division-by-zero errors.  Other kinds of errors will
1210 not be handled (by this @code{condition-case}).  Thus:
1212 @example
1213 @group
1214 (safe-divide nil 3)
1215      @error{} Wrong type argument: number-or-marker-p, nil
1216 @end group
1217 @end example
1219   Here is a @code{condition-case} that catches all kinds of errors,
1220 including those from @code{error}:
1222 @example
1223 @group
1224 (setq baz 34)
1225      @result{} 34
1226 @end group
1228 @group
1229 (condition-case err
1230     (if (eq baz 35)
1231         t
1232       ;; @r{This is a call to the function @code{error}.}
1233       (error "Rats!  The variable %s was %s, not 35" 'baz baz))
1234   ;; @r{This is the handler; it is not a form.}
1235   (error (princ (format "The error was: %s" err))
1236          2))
1237 @print{} The error was: (error "Rats!  The variable baz was 34, not 35")
1238 @result{} 2
1239 @end group
1240 @end example
1242 @defmac ignore-errors body@dots{}
1243 This construct executes @var{body}, ignoring any errors that occur
1244 during its execution.  If the execution is without error,
1245 @code{ignore-errors} returns the value of the last form in @var{body};
1246 otherwise, it returns @code{nil}.
1248 Here's the example at the beginning of this subsection rewritten using
1249 @code{ignore-errors}:
1251 @example
1252 @group
1253   (ignore-errors
1254    (delete-file filename))
1255 @end group
1256 @end example
1257 @end defmac
1259 @defmac with-demoted-errors format body@dots{}
1260 This macro is like a milder version of @code{ignore-errors}.  Rather
1261 than suppressing errors altogether, it converts them into messages.
1262 It uses the string @var{format} to format the message.
1263 @var{format} should contain a single @samp{%}-sequence; e.g.,
1264 @code{"Error: %S"}.  Use @code{with-demoted-errors} around code
1265 that is not expected to signal errors, but
1266 should be robust if one does occur.  Note that this macro uses
1267 @code{condition-case-unless-debug} rather than @code{condition-case}.
1268 @end defmac
1270 @node Error Symbols
1271 @subsubsection Error Symbols and Condition Names
1272 @cindex error symbol
1273 @cindex error name
1274 @cindex condition name
1275 @cindex user-defined error
1276 @kindex error-conditions
1277 @kindex define-error
1279   When you signal an error, you specify an @dfn{error symbol} to specify
1280 the kind of error you have in mind.  Each error has one and only one
1281 error symbol to categorize it.  This is the finest classification of
1282 errors defined by the Emacs Lisp language.
1284   These narrow classifications are grouped into a hierarchy of wider
1285 classes called @dfn{error conditions}, identified by @dfn{condition
1286 names}.  The narrowest such classes belong to the error symbols
1287 themselves: each error symbol is also a condition name.  There are also
1288 condition names for more extensive classes, up to the condition name
1289 @code{error} which takes in all kinds of errors (but not @code{quit}).
1290 Thus, each error has one or more condition names: @code{error}, the
1291 error symbol if that is distinct from @code{error}, and perhaps some
1292 intermediate classifications.
1294 @defun define-error name message &optional parent
1295   In order for a symbol to be an error symbol, it must be defined with
1296 @code{define-error} which takes a parent condition (defaults to @code{error}).
1297 This parent defines the conditions that this kind of error belongs to.
1298 The transitive set of parents always includes the error symbol itself, and the
1299 symbol @code{error}.  Because quitting is not considered an error, the set of
1300 parents of @code{quit} is just @code{(quit)}.
1301 @end defun
1303 @cindex peculiar error
1304   In addition to its parents, the error symbol has a @var{message} which
1305 is a string to be printed when that error is signaled but not handled.  If that
1306 message is not valid, the error message @samp{peculiar error} is used.
1307 @xref{Definition of signal}.
1309 Internally, the set of parents is stored in the @code{error-conditions}
1310 property of the error symbol and the message is stored in the
1311 @code{error-message} property of the error symbol.
1313   Here is how we define a new error symbol, @code{new-error}:
1315 @example
1316 @group
1317 (define-error 'new-error "A new error" 'my-own-errors)
1318 @end group
1319 @end example
1321 @noindent
1322 This error has several condition names: @code{new-error}, the narrowest
1323 classification; @code{my-own-errors}, which we imagine is a wider
1324 classification; and all the conditions of @code{my-own-errors} which should
1325 include @code{error}, which is the widest of all.
1327   The error string should start with a capital letter but it should
1328 not end with a period.  This is for consistency with the rest of Emacs.
1330   Naturally, Emacs will never signal @code{new-error} on its own; only
1331 an explicit call to @code{signal} (@pxref{Definition of signal}) in
1332 your code can do this:
1334 @example
1335 @group
1336 (signal 'new-error '(x y))
1337      @error{} A new error: x, y
1338 @end group
1339 @end example
1341   This error can be handled through any of its condition names.
1342 This example handles @code{new-error} and any other errors in the class
1343 @code{my-own-errors}:
1345 @example
1346 @group
1347 (condition-case foo
1348     (bar nil t)
1349   (my-own-errors nil))
1350 @end group
1351 @end example
1353   The significant way that errors are classified is by their condition
1354 names---the names used to match errors with handlers.  An error symbol
1355 serves only as a convenient way to specify the intended error message
1356 and list of condition names.  It would be cumbersome to give
1357 @code{signal} a list of condition names rather than one error symbol.
1359   By contrast, using only error symbols without condition names would
1360 seriously decrease the power of @code{condition-case}.  Condition names
1361 make it possible to categorize errors at various levels of generality
1362 when you write an error handler.  Using error symbols alone would
1363 eliminate all but the narrowest level of classification.
1365   @xref{Standard Errors}, for a list of the main error symbols
1366 and their conditions.
1368 @node Cleanups
1369 @subsection Cleaning Up from Nonlocal Exits
1371   The @code{unwind-protect} construct is essential whenever you
1372 temporarily put a data structure in an inconsistent state; it permits
1373 you to make the data consistent again in the event of an error or
1374 throw.  (Another more specific cleanup construct that is used only for
1375 changes in buffer contents is the atomic change group; @ref{Atomic
1376 Changes}.)
1378 @defspec unwind-protect body-form cleanup-forms@dots{}
1379 @cindex cleanup forms
1380 @cindex protected forms
1381 @cindex error cleanup
1382 @cindex unwinding
1383 @code{unwind-protect} executes @var{body-form} with a guarantee that
1384 the @var{cleanup-forms} will be evaluated if control leaves
1385 @var{body-form}, no matter how that happens.  @var{body-form} may
1386 complete normally, or execute a @code{throw} out of the
1387 @code{unwind-protect}, or cause an error; in all cases, the
1388 @var{cleanup-forms} will be evaluated.
1390 If @var{body-form} finishes normally, @code{unwind-protect} returns the
1391 value of @var{body-form}, after it evaluates the @var{cleanup-forms}.
1392 If @var{body-form} does not finish, @code{unwind-protect} does not
1393 return any value in the normal sense.
1395 Only @var{body-form} is protected by the @code{unwind-protect}.  If any
1396 of the @var{cleanup-forms} themselves exits nonlocally (via a
1397 @code{throw} or an error), @code{unwind-protect} is @emph{not}
1398 guaranteed to evaluate the rest of them.  If the failure of one of the
1399 @var{cleanup-forms} has the potential to cause trouble, then protect
1400 it with another @code{unwind-protect} around that form.
1402 The number of currently active @code{unwind-protect} forms counts,
1403 together with the number of local variable bindings, against the limit
1404 @code{max-specpdl-size} (@pxref{Definition of max-specpdl-size,, Local
1405 Variables}).
1406 @end defspec
1408   For example, here we make an invisible buffer for temporary use, and
1409 make sure to kill it before finishing:
1411 @example
1412 @group
1413 (let ((buffer (get-buffer-create " *temp*")))
1414   (with-current-buffer buffer
1415     (unwind-protect
1416         @var{body-form}
1417       (kill-buffer buffer))))
1418 @end group
1419 @end example
1421 @noindent
1422 You might think that we could just as well write @code{(kill-buffer
1423 (current-buffer))} and dispense with the variable @code{buffer}.
1424 However, the way shown above is safer, if @var{body-form} happens to
1425 get an error after switching to a different buffer!  (Alternatively,
1426 you could write a @code{save-current-buffer} around @var{body-form},
1427 to ensure that the temporary buffer becomes current again in time to
1428 kill it.)
1430   Emacs includes a standard macro called @code{with-temp-buffer} which
1431 expands into more or less the code shown above (@pxref{Definition of
1432 with-temp-buffer,, Current Buffer}).  Several of the macros defined in
1433 this manual use @code{unwind-protect} in this way.
1435 @findex ftp-login
1436   Here is an actual example derived from an FTP package.  It creates a
1437 process (@pxref{Processes}) to try to establish a connection to a remote
1438 machine.  As the function @code{ftp-login} is highly susceptible to
1439 numerous problems that the writer of the function cannot anticipate, it
1440 is protected with a form that guarantees deletion of the process in the
1441 event of failure.  Otherwise, Emacs might fill up with useless
1442 subprocesses.
1444 @example
1445 @group
1446 (let ((win nil))
1447   (unwind-protect
1448       (progn
1449         (setq process (ftp-setup-buffer host file))
1450         (if (setq win (ftp-login process host user password))
1451             (message "Logged in")
1452           (error "Ftp login failed")))
1453     (or win (and process (delete-process process)))))
1454 @end group
1455 @end example
1457   This example has a small bug: if the user types @kbd{C-g} to
1458 quit, and the quit happens immediately after the function
1459 @code{ftp-setup-buffer} returns but before the variable @code{process} is
1460 set, the process will not be killed.  There is no easy way to fix this bug,
1461 but at least it is very unlikely.