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