1 /* unwind_prot.c - a simple unwind-protect system for internal variables */
3 /* I can't stand it anymore! Please can't we just write the
4 whole Unix system in lisp or something? */
6 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software: you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or
13 (at your option) any later version.
15 Bash is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with Bash. If not, see <http://www.gnu.org/licenses/>.
24 /* **************************************************************** */
26 /* Unwind Protection Scheme for Bash */
28 /* **************************************************************** */
31 #include "bashtypes.h"
34 #if defined (HAVE_UNISTD_H)
43 # define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
48 #include "unwind_prot.h"
51 #include "error.h" /* for internal_warning */
53 /* Structure describing a saved variable and the value to restore it to. */
57 char desired_setting[1]; /* actual size is `size' */
60 /* If HEAD.CLEANUP is null, then ARG.V contains a tag to throw back to.
61 If HEAD.CLEANUP is restore_variable, then SV.V contains the saved
62 variable. Otherwise, call HEAD.CLEANUP (ARG.V) to clean up. */
69 struct uwp_head uwp_head;
73 struct uwp_head uwp_head;
79 static void without_interrupts __P((VFunction *, char *, char *));
80 static void unwind_frame_discard_internal __P((char *, char *));
81 static void unwind_frame_run_internal __P((char *, char *));
82 static void add_unwind_protect_internal __P((Function *, char *));
83 static void remove_unwind_protect_internal __P((char *, char *));
84 static void run_unwind_protects_internal __P((char *, char *));
85 static void clear_unwind_protects_internal __P((char *, char *));
86 static inline void restore_variable __P((SAVED_VAR *));
87 static void unwind_protect_mem_internal __P((char *, char *));
89 static UNWIND_ELT *unwind_protect_list = (UNWIND_ELT *)NULL;
91 #define uwpalloc(elt) (elt) = (UNWIND_ELT *)xmalloc (sizeof (UNWIND_ELT))
92 #define uwpfree(elt) free(elt)
94 /* Run a function without interrupts. This relies on the fact that the
95 FUNCTION cannot change the value of interrupt_immediately. (I.e., does
98 without_interrupts (function, arg1, arg2)
102 int old_interrupt_immediately;
104 old_interrupt_immediately = interrupt_immediately;
105 interrupt_immediately = 0;
107 (*function)(arg1, arg2);
109 interrupt_immediately = old_interrupt_immediately;
112 /* Start the beginning of a region. */
114 begin_unwind_frame (tag)
117 add_unwind_protect ((Function *)NULL, tag);
120 /* Discard the unwind protects back to TAG. */
122 discard_unwind_frame (tag)
125 if (unwind_protect_list)
126 without_interrupts (unwind_frame_discard_internal, tag, (char *)NULL);
129 /* Run the unwind protects back to TAG. */
131 run_unwind_frame (tag)
134 if (unwind_protect_list)
135 without_interrupts (unwind_frame_run_internal, tag, (char *)NULL);
138 /* Add the function CLEANUP with ARG to the list of unwindable things. */
140 add_unwind_protect (cleanup, arg)
144 without_interrupts (add_unwind_protect_internal, (char *)cleanup, arg);
147 /* Remove the top unwind protect from the list. */
149 remove_unwind_protect ()
151 if (unwind_protect_list)
153 (remove_unwind_protect_internal, (char *)NULL, (char *)NULL);
156 /* Run the list of cleanup functions in unwind_protect_list. */
158 run_unwind_protects ()
160 if (unwind_protect_list)
162 (run_unwind_protects_internal, (char *)NULL, (char *)NULL);
165 /* Erase the unwind-protect list. If flags is 1, free the elements. */
167 clear_unwind_protect_list (flags)
172 if (unwind_protect_list)
174 flag = flags ? "" : (char *)NULL;
176 (clear_unwind_protects_internal, flag, (char *)NULL);
181 have_unwind_protects ()
183 return (unwind_protect_list != 0);
186 /* **************************************************************** */
188 /* The Actual Functions */
190 /* **************************************************************** */
193 add_unwind_protect_internal (cleanup, arg)
200 elt->head.next = unwind_protect_list;
201 elt->head.cleanup = cleanup;
203 unwind_protect_list = elt;
207 remove_unwind_protect_internal (ignore1, ignore2)
208 char *ignore1, *ignore2;
212 elt = unwind_protect_list;
215 unwind_protect_list = unwind_protect_list->head.next;
221 run_unwind_protects_internal (ignore1, ignore2)
222 char *ignore1, *ignore2;
224 unwind_frame_run_internal ((char *) NULL, (char *) NULL);
228 clear_unwind_protects_internal (flag, ignore)
233 while (unwind_protect_list)
234 remove_unwind_protect_internal ((char *)NULL, (char *)NULL);
236 unwind_protect_list = (UNWIND_ELT *)NULL;
240 unwind_frame_discard_internal (tag, ignore)
247 while (elt = unwind_protect_list)
249 unwind_protect_list = unwind_protect_list->head.next;
250 if (elt->head.cleanup == 0 && (STREQ (elt->arg.v, tag)))
261 internal_warning ("unwind_frame_discard: %s: frame not found", tag);
264 /* Restore the value of a variable, based on the contents of SV.
265 sv->desired_setting is a block of memory SIZE bytes long holding the
266 value itself. This block of memory is copied back into the variable. */
268 restore_variable (sv)
271 FASTCOPY (sv->desired_setting, sv->variable, sv->size);
275 unwind_frame_run_internal (tag, ignore)
282 while (elt = unwind_protect_list)
284 unwind_protect_list = elt->head.next;
286 /* If tag, then compare. */
287 if (elt->head.cleanup == 0)
289 if (tag && STREQ (elt->arg.v, tag))
298 if (elt->head.cleanup == (Function *) restore_variable)
299 restore_variable (&elt->sv.v);
301 (*(elt->head.cleanup)) (elt->arg.v);
306 if (tag && found == 0)
307 internal_warning ("unwind_frame_run: %s: frame not found", tag);
311 unwind_protect_mem_internal (var, psize)
318 size = *(int *) psize;
319 allocated = size + offsetof (UNWIND_ELT, sv.v.desired_setting[0]);
320 elt = (UNWIND_ELT *)xmalloc (allocated);
321 elt->head.next = unwind_protect_list;
322 elt->head.cleanup = (Function *) restore_variable;
323 elt->sv.v.variable = var;
324 elt->sv.v.size = size;
325 FASTCOPY (var, elt->sv.v.desired_setting, size);
326 unwind_protect_list = elt;
329 /* Save the value of a variable so it will be restored when unwind-protects
330 are run. VAR is a pointer to the variable. SIZE is the size in
333 unwind_protect_mem (var, size)
337 without_interrupts (unwind_protect_mem_internal, var, (char *) &size);
344 print_unwind_protect_tags ()
348 elt = unwind_protect_list;
351 unwind_protect_list = unwind_protect_list->head.next;
352 if (elt->head.cleanup == 0)
353 fprintf(stderr, "tag: %s\n", elt->arg.v);
354 elt = unwind_protect_list;