fd384b49741e3cae51876fbff2024b530088ed82
[kopensolaris-gnu/glibc.git] / manual / setjmp.texi
1 @node Non-Local Exits, Signal Handling, Date and Time, Top
2 @chapter Non-Local Exits
3 @cindex non-local exits
4 @cindex long jumps
5
6 Sometimes when your program detects an unusual situation inside a deeply
7 nested set of function calls, you would like to be able to immediately
8 return to an outer level of control.  This section describes how you can
9 do such @dfn{non-local exits} using the @code{setjmp} and @code{longjmp}
10 functions.
11
12 @menu
13 * Intro: Non-Local Intro.        When and how to use these facilities.
14 * Details: Non-Local Details::   Functions for nonlocal exits.
15 * Non-Local Exits and Signals::  Portability issues.
16 @end menu
17
18 @node Non-Local Intro, Non-Local Details,  , Non-Local Exits
19 @section Introduction to Non-Local Exits
20
21 As an example of a situation where a non-local exit can be useful,
22 suppose you have an interactive program that has a ``main loop'' that
23 prompts for and executes commands.  Suppose the ``read'' command reads
24 input from a file, doing some lexical analysis and parsing of the input
25 while processing it.  If a low-level input error is detected, it would
26 be useful to be able to return immediately to the ``main loop'' instead
27 of having to make each of the lexical analysis, parsing, and processing
28 phases all have to explicitly deal with error situations initially
29 detected by nested calls.
30
31 (On the other hand, if each of these phases has to do a substantial
32 amount of cleanup when it exits---such as closing files, deallocating
33 buffers or other data structures, and the like---then it can be more
34 appropriate to do a normal return and have each phase do its own
35 cleanup, because a non-local exit would bypass the intervening phases and
36 their associated cleanup code entirely.  Alternatively, you could use a
37 non-local exit but do the cleanup explicitly either before or after
38 returning to the ``main loop''.)
39
40 In some ways, a non-local exit is similar to using the @samp{return}
41 statement to return from a function.  But while @samp{return} abandons
42 only a single function call, transferring control back to the point at
43 which it was called, a non-local exit can potentially abandon many
44 levels of nested function calls.
45
46 You identify return points for non-local exits calling the function
47 @code{setjmp}.  This function saves information about the execution
48 environment in which the call to @code{setjmp} appears in an object of
49 type @code{jmp_buf}.  Execution of the program continues normally after
50 the call to @code{setjmp}, but if a exit is later made to this return
51 point by calling @code{longjmp} with the corresponding @code{jmp_buf}
52 object, control is transferred back to the point where @code{setjmp} was
53 called.  The return value from @code{setjmp} is used to distinguish
54 between an ordinary return and a return made by a call to
55 @code{longjmp}, so calls to @code{setjmp} usually appear in an @samp{if}
56 statement.
57
58 Here is how the example program described above might be set up:  
59
60 @example
61 @include setjmp.c.texi
62 @end example
63
64 The function @code{abort_to_main_loop} causes an immediate transfer of
65 control back to the main loop of the program, no matter where it is
66 called from.
67
68 The flow of control inside the @code{main} function may appear a little
69 mysterious at first, but it is actually a common idiom with
70 @code{setjmp}.  A normal call to @code{setjmp} returns zero, so the
71 ``else'' clause of the conditional is executed.  If
72 @code{abort_to_main_loop} is called somewhere within the execution of
73 @code{do_command}, then it actually appears as if the @emph{same} call
74 to @code{setjmp} in @code{main} were returning a second time with a value
75 of @code{-1}.
76
77 So, the general pattern for using @code{setjmp} looks something like:
78
79 @example
80 if (setjmp (@var{buffer}))
81   /* @r{Code to clean up after premature return.} */
82   @dots{}
83 else
84   /* @r{Code to be executed normally after setting up the return point.} */
85   @dots{}
86 @end example
87
88 @node Non-Local Details, Non-Local Exits and Signals, Non-Local Intro, Non-Local Exits
89 @section Details of Non-Local Exits
90
91 Here are the details on the functions and data structures used for
92 performing non-local exits.  These facilities are declared in
93 @file{setjmp.h}.
94 @pindex setjmp.h
95
96 @comment setjmp.h
97 @comment ANSI
98 @deftp {Data Type} jmp_buf
99 Objects of type @code{jmp_buf} hold the state information to
100 be restored by a non-local exit.  The contents of a @code{jmp_buf}
101 identify a specific place to return to.
102 @end deftp
103
104 @comment setjmp.h
105 @comment ANSI
106 @deftypefun int setjmp (jmp_buf @var{state})
107 When called normally, @code{setjmp} stores information about the
108 execution state of the program in @var{state} and returns zero.  If
109 @code{longjmp} is later used to perform a non-local exit to this
110 @var{state}, @code{setjmp} returns a nonzero value.
111 @end deftypefun
112
113 @comment setjmp.h
114 @comment ANSI
115 @deftypefun void longjmp (jmp_buf @var{state}, int @var{value}) 
116 This function restores current execution to the state saved in
117 @var{state}, and continues execution from the call to @code{setjmp} that
118 established that return point.  Returning from @code{setjmp} by means of
119 @code{longjmp} returns the @var{value} argument that was passed to
120 @code{longjmp}, rather than @code{0}.  (But if @var{value} is given as
121 @code{0}, @code{setjmp} returns @code{1}).@refill
122 @end deftypefun
123
124 There are a lot of obscure but important restrictions on the use of
125 @code{setjmp} and @code{longjmp}.  Most of these restrictions are
126 present because non-local exits require a fair amount of magic on the
127 part of the C compiler and can interact with other parts of the language
128 in strange ways.
129
130 The @code{setjmp} function may be implemented as a macro without an
131 actual function definition, so you shouldn't try to @samp{#undef} it or
132 take its address.  In addition, calls to @code{setjmp} are safe in only
133 the following contexts:
134
135 @itemize @bullet
136 @item
137 As the test expression of a selection or iteration
138 statement (such as @samp{if} or @samp{while}).
139
140 @item
141 As one operand of a equality or comparison operator that appears as the
142 test expression of a selection or iteration statement.  The other
143 operand must be an integer constant expression.
144
145 @item
146 As the operand of a unary @samp{!} operator, that appears as the
147 test expression of a selection or iteration statement.
148
149 @item
150 By itself as an expression statement.
151 @end itemize
152
153 Return points are valid only during the dynamic extent of the function
154 that called @code{setjmp} to establish them.  If you @code{longjmp} to
155 a return point that was established in a function that has already
156 returned, unpredictable and disastrous things are likely to happen.
157
158 You should use a nonzero @var{value} argument to @code{longjmp}.  While
159 @code{longjmp} refuses to pass back a zero argument as the return value
160 from @code{setjmp}, this is intended as a safety net against accidental
161 misuse and is not really good programming style.
162
163 When you perform a non-local exit, accessible objects generally retain
164 whatever values they had at the time @code{longjmp} was called.  The
165 exception is that the values of automatic variables local to the
166 function containing the @code{setjmp} call that have been changed since
167 the call to @code{setjmp} are indeterminate, unless you have declared
168 them @code{volatile}.
169
170 @node Non-Local Exits and Signals,, Non-Local Details, Non-Local Exits
171 @section Non-Local Exits and Signals
172
173 In BSD Unix systems, @code{setjmp} and @code{longjmp} also save and
174 restore the set of blocked signals; see @ref{Blocking Signals}.  However,
175 the POSIX.1 standard requires @code{setjmp} and @code{longjmp} not to
176 change the set of blocked signals, and provides an additional pair of
177 functions (@code{sigsetjmp} and @code{sigsetjmp}) to get the BSD
178 behavior.
179
180 The behavior of @code{setjmp} and @code{longjmp} in the GNU library is
181 controlled by feature test macros; see @ref{Feature Test Macros}.  The
182 default in the GNU system is the POSIX.1 behavior rather than the BSD
183 behavior.
184
185 The facilities in this section are declared in the header file
186 @file{setjmp.h}.
187 @pindex setjmp.h
188
189 @comment setjmp.h
190 @comment POSIX.1
191 @deftp {Data Type} sigjmp_buf
192 This is similar to @code{jmp_buf}, except that it can also store state
193 information about the set of blocked signals.
194 @end deftp
195
196 @comment setjmp.h
197 @comment POSIX.1
198 @deftypefun int sigsetjmp (sigjmp_buf @var{state}, int @var{savesigs})
199 This is similar to @code{setjmp}.  If @var{savesigs} is nonzero, the set
200 of blocked signals is saved in @var{state} and will be restored if a
201 @code{siglongjmp} is later performed with this @var{state}.
202 @end deftypefun
203
204 @comment setjmp.h
205 @comment POSIX.1
206 @deftypefun void siglongjmp (sigjmp_buf @var{state}, int @var{value})
207 This is similar to @code{longjmp} except for the type of its @var{state}
208 argument.
209 @end deftypefun
210