[thirdparty/bash.git] / unwind_prot.c

/* unwind_prot.c - a simple unwind-protect system for internal variables */

/* I can't stand it anymore!  Please can't we just write the
   whole Unix system in lisp or something? */

/* Copyright (C) 1987-2009 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   Bash is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
*/

/* **************************************************************** */
/*								    */
/*		      Unwind Protection Scheme for Bash		    */
/*								    */
/* **************************************************************** */
#include "config.h"

#include "bashtypes.h"
#include "bashansi.h"

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif

#if STDC_HEADERS
#  include <stddef.h>
#endif

#ifndef offsetof
#  define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#endif

#include "command.h"
#include "general.h"
#include "unwind_prot.h"
#include "quit.h"
#include "sig.h"
#include "error.h"	/* for internal_warning */

/* Structure describing a saved variable and the value to restore it to.  */
typedef struct {
  char *variable;
  int size;
  char desired_setting[1]; /* actual size is `size' */
} SAVED_VAR;

/* If HEAD.CLEANUP is null, then ARG.V contains a tag to throw back to.
   If HEAD.CLEANUP is restore_variable, then SV.V contains the saved
   variable.  Otherwise, call HEAD.CLEANUP (ARG.V) to clean up.  */
typedef union uwp {
  struct uwp_head {
    union uwp *next;
    Function *cleanup;
  } head;
  struct {
    struct uwp_head uwp_head;
    char *v;
  } arg;
  struct {
    struct uwp_head uwp_head;
    SAVED_VAR v;
  } sv;
} UNWIND_ELT;


static void without_interrupts __P((VFunction *, char *, char *));
static void unwind_frame_discard_internal __P((char *, char *));
static void unwind_frame_run_internal __P((char *, char *));
static void add_unwind_protect_internal __P((Function *, char *));
static void remove_unwind_protect_internal __P((char *, char *));
static void run_unwind_protects_internal __P((char *, char *));
static void clear_unwind_protects_internal __P((char *, char *));
static inline void restore_variable __P((SAVED_VAR *));
static void unwind_protect_mem_internal __P((char *, char *));

static UNWIND_ELT *unwind_protect_list = (UNWIND_ELT *)NULL;

#define uwpalloc(elt)	(elt) = (UNWIND_ELT *)xmalloc (sizeof (UNWIND_ELT))
#define uwpfree(elt)	free(elt)

/* Run a function without interrupts.  This relies on the fact that the
   FUNCTION cannot change the value of interrupt_immediately.  (I.e., does
   not call QUIT (). */
static void
without_interrupts (function, arg1, arg2)
     VFunction *function;
     char *arg1, *arg2;
{
  int old_interrupt_immediately;

  old_interrupt_immediately = interrupt_immediately;
  interrupt_immediately = 0;

  (*function)(arg1, arg2);

  interrupt_immediately = old_interrupt_immediately;
}

/* Start the beginning of a region. */
void
begin_unwind_frame (tag)
     char *tag;
{
  add_unwind_protect ((Function *)NULL, tag);
}

/* Discard the unwind protects back to TAG. */
void
discard_unwind_frame (tag)
     char *tag;
{
  if (unwind_protect_list)
    without_interrupts (unwind_frame_discard_internal, tag, (char *)NULL);
}

/* Run the unwind protects back to TAG. */
void
run_unwind_frame (tag)
     char *tag;
{
  if (unwind_protect_list)
    without_interrupts (unwind_frame_run_internal, tag, (char *)NULL);
}

/* Add the function CLEANUP with ARG to the list of unwindable things. */
void
add_unwind_protect (cleanup, arg)
     Function *cleanup;
     char *arg;
{
  without_interrupts (add_unwind_protect_internal, (char *)cleanup, arg);
}

/* Remove the top unwind protect from the list. */
void
remove_unwind_protect ()
{
  if (unwind_protect_list)
    without_interrupts
      (remove_unwind_protect_internal, (char *)NULL, (char *)NULL);
}

/* Run the list of cleanup functions in unwind_protect_list. */
void
run_unwind_protects ()
{
  if (unwind_protect_list)
    without_interrupts
      (run_unwind_protects_internal, (char *)NULL, (char *)NULL);
}

/* Erase the unwind-protect list.  If flags is 1, free the elements. */
void
clear_unwind_protect_list (flags)
     int flags;
{
  char *flag;

  if (unwind_protect_list)
    {
      flag = flags ? "" : (char *)NULL;
      without_interrupts
        (clear_unwind_protects_internal, flag, (char *)NULL);
    }
}

int
have_unwind_protects ()
{
  return (unwind_protect_list != 0);
}

/* **************************************************************** */
/*								    */
/*			The Actual Functions		 	    */
/*								    */
/* **************************************************************** */

static void
add_unwind_protect_internal (cleanup, arg)
     Function *cleanup;
     char *arg;
{
  UNWIND_ELT *elt;

  uwpalloc (elt);
  elt->head.next = unwind_protect_list;
  elt->head.cleanup = cleanup;
  elt->arg.v = arg;
  unwind_protect_list = elt;
}

static void
remove_unwind_protect_internal (ignore1, ignore2)
     char *ignore1, *ignore2;
{
  UNWIND_ELT *elt;

  elt = unwind_protect_list;
  if (elt)
    {
      unwind_protect_list = unwind_protect_list->head.next;
      uwpfree (elt);
    }
}

static void
run_unwind_protects_internal (ignore1, ignore2)
     char *ignore1, *ignore2;
{
  unwind_frame_run_internal ((char *) NULL, (char *) NULL);
}

static void
clear_unwind_protects_internal (flag, ignore)
     char *flag, *ignore;
{
  if (flag)
    {
      while (unwind_protect_list)
	remove_unwind_protect_internal ((char *)NULL, (char *)NULL);
    }
  unwind_protect_list = (UNWIND_ELT *)NULL;
}

static void
unwind_frame_discard_internal (tag, ignore)
     char *tag, *ignore;
{
  UNWIND_ELT *elt;
  int found;

  found = 0;
  while (elt = unwind_protect_list)
    {
      unwind_protect_list = unwind_protect_list->head.next;
      if (elt->head.cleanup == 0 && (STREQ (elt->arg.v, tag)))
	{
	  uwpfree (elt);
	  found = 1;
	  break;
	}
      else
	uwpfree (elt);
    }

  if (found == 0)
    internal_warning ("unwind_frame_discard: %s: frame not found", tag);
}

/* Restore the value of a variable, based on the contents of SV.
   sv->desired_setting is a block of memory SIZE bytes long holding the
   value itself.  This block of memory is copied back into the variable. */
static inline void
restore_variable (sv)
     SAVED_VAR *sv;
{
  FASTCOPY (sv->desired_setting, sv->variable, sv->size);
}

static void
unwind_frame_run_internal (tag, ignore)
     char *tag, *ignore;
{
  UNWIND_ELT *elt;
  int found;

  found = 0;
  while (elt = unwind_protect_list)
    {
      unwind_protect_list = elt->head.next;

      /* If tag, then compare. */
      if (elt->head.cleanup == 0)
	{
	  if (tag && STREQ (elt->arg.v, tag))
	    {
	      uwpfree (elt);
	      found = 1;
	      break;
	    }
	}
      else
	{
	  if (elt->head.cleanup == (Function *) restore_variable)
	    restore_variable (&elt->sv.v);
	  else
	    (*(elt->head.cleanup)) (elt->arg.v);
	}

      uwpfree (elt);
    }
  if (tag && found == 0)
    internal_warning ("unwind_frame_run: %s: frame not found", tag);
}

static void
unwind_protect_mem_internal (var, psize)
     char *var;
     char *psize;
{
  int size, allocated;
  UNWIND_ELT *elt;

  size = *(int *) psize;
  allocated = size + offsetof (UNWIND_ELT, sv.v.desired_setting[0]);
  elt = (UNWIND_ELT *)xmalloc (allocated);
  elt->head.next = unwind_protect_list;
  elt->head.cleanup = (Function *) restore_variable;
  elt->sv.v.variable = var;
  elt->sv.v.size = size;
  FASTCOPY (var, elt->sv.v.desired_setting, size);
  unwind_protect_list = elt;
}

/* Save the value of a variable so it will be restored when unwind-protects
   are run.  VAR is a pointer to the variable.  SIZE is the size in
   bytes of VAR.  */
void
unwind_protect_mem (var, size)
     char *var;
     int size;
{
  without_interrupts (unwind_protect_mem_internal, var, (char *) &size);
}

#if defined (DEBUG)
#include <stdio.h>

void
print_unwind_protect_tags ()
{
  UNWIND_ELT *elt;

  elt = unwind_protect_list;
  while (elt)
    {
      unwind_protect_list = unwind_protect_list->head.next;
      if (elt->head.cleanup == 0)
        fprintf(stderr, "tag: %s\n", elt->arg.v);
      elt = unwind_protect_list;
    }
}
#endif
Commit	Line	Data
	1	/* unwind_prot.c - a simple unwind-protect system for internal variables */
	2
	3	/* I can't stand it anymore! Please can't we just write the
	4	whole Unix system in lisp or something? */
	5
	6	/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
	7
	8	This file is part of GNU Bash, the Bourne Again SHell.
	9
	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.
	14
	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.
	19
	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/>.
	22	*/
	23
	24	/* **************************************************************** */
	25	/* */
	26	/* Unwind Protection Scheme for Bash */
	27	/* */
	28	/* **************************************************************** */
	29	#include "config.h"
	30
	31	#include "bashtypes.h"
	32	#include "bashansi.h"
	33
	34	#if defined (HAVE_UNISTD_H)
	35	# include <unistd.h>
	36	#endif
	37
	38	#if STDC_HEADERS
	39	# include <stddef.h>
	40	#endif
	41
	42	#ifndef offsetof
	43	# define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
	44	#endif
	45
	46	#include "command.h"
	47	#include "general.h"
	48	#include "unwind_prot.h"
	49	#include "quit.h"
	50	#include "sig.h"
	51	#include "error.h" /* for internal_warning */
	52
	53	/* Structure describing a saved variable and the value to restore it to. */
	54	typedef struct {
	55	char *variable;
	56	int size;
	57	char desired_setting[1]; /* actual size is `size' */
	58	} SAVED_VAR;
	59
	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. */
	63	typedef union uwp {
	64	struct uwp_head {
	65	union uwp *next;
	66	Function *cleanup;
	67	} head;
	68	struct {
	69	struct uwp_head uwp_head;
	70	char *v;
	71	} arg;
	72	struct {
	73	struct uwp_head uwp_head;
	74	SAVED_VAR v;
	75	} sv;
	76	} UNWIND_ELT;
	77
	78
	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 ));
	88
	89	static UNWIND_ELT unwind_protect_list = (UNWIND_ELT )NULL;
	90
	91	#define uwpalloc(elt) (elt) = (UNWIND_ELT *)xmalloc (sizeof (UNWIND_ELT))
	92	#define uwpfree(elt) free(elt)
	93
	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
	96	not call QUIT (). */
	97	static void
	98	without_interrupts (function, arg1, arg2)
	99	VFunction *function;
	100	char arg1, arg2;
	101	{
	102	int old_interrupt_immediately;
	103
	104	old_interrupt_immediately = interrupt_immediately;
	105	interrupt_immediately = 0;
	106
	107	(*function)(arg1, arg2);
	108
	109	interrupt_immediately = old_interrupt_immediately;
	110	}
	111
	112	/* Start the beginning of a region. */
	113	void
	114	begin_unwind_frame (tag)
	115	char *tag;
	116	{
	117	add_unwind_protect ((Function *)NULL, tag);
	118	}
	119
	120	/* Discard the unwind protects back to TAG. */
	121	void
	122	discard_unwind_frame (tag)
	123	char *tag;
	124	{
	125	if (unwind_protect_list)
	126	without_interrupts (unwind_frame_discard_internal, tag, (char *)NULL);
	127	}
	128
	129	/* Run the unwind protects back to TAG. */
	130	void
	131	run_unwind_frame (tag)
	132	char *tag;
	133	{
	134	if (unwind_protect_list)
	135	without_interrupts (unwind_frame_run_internal, tag, (char *)NULL);
	136	}
	137
	138	/* Add the function CLEANUP with ARG to the list of unwindable things. */
	139	void
	140	add_unwind_protect (cleanup, arg)
	141	Function *cleanup;
	142	char *arg;
	143	{
	144	without_interrupts (add_unwind_protect_internal, (char *)cleanup, arg);
	145	}
	146
	147	/* Remove the top unwind protect from the list. */
	148	void
	149	remove_unwind_protect ()
	150	{
	151	if (unwind_protect_list)
	152	without_interrupts
	153	(remove_unwind_protect_internal, (char )NULL, (char )NULL);
	154	}
	155
	156	/* Run the list of cleanup functions in unwind_protect_list. */
	157	void
	158	run_unwind_protects ()
	159	{
	160	if (unwind_protect_list)
	161	without_interrupts
	162	(run_unwind_protects_internal, (char )NULL, (char )NULL);
	163	}
	164
	165	/* Erase the unwind-protect list. If flags is 1, free the elements. */
	166	void
	167	clear_unwind_protect_list (flags)
	168	int flags;
	169	{
	170	char *flag;
	171
	172	if (unwind_protect_list)
	173	{
	174	flag = flags ? "" : (char *)NULL;
	175	without_interrupts
	176	(clear_unwind_protects_internal, flag, (char *)NULL);
	177	}
	178	}
	179
	180	int
	181	have_unwind_protects ()
	182	{
	183	return (unwind_protect_list != 0);
	184	}
	185
	186	/* **************************************************************** */
	187	/* */
	188	/* The Actual Functions */
	189	/* */
	190	/* **************************************************************** */
	191
	192	static void
	193	add_unwind_protect_internal (cleanup, arg)
	194	Function *cleanup;
	195	char *arg;
	196	{
	197	UNWIND_ELT *elt;
	198
	199	uwpalloc (elt);
	200	elt->head.next = unwind_protect_list;
	201	elt->head.cleanup = cleanup;
	202	elt->arg.v = arg;
	203	unwind_protect_list = elt;
	204	}
	205
	206	static void
	207	remove_unwind_protect_internal (ignore1, ignore2)
	208	char ignore1, ignore2;
	209	{
	210	UNWIND_ELT *elt;
	211
	212	elt = unwind_protect_list;
	213	if (elt)
	214	{
	215	unwind_protect_list = unwind_protect_list->head.next;
	216	uwpfree (elt);
	217	}
	218	}
	219
	220	static void
	221	run_unwind_protects_internal (ignore1, ignore2)
	222	char ignore1, ignore2;
	223	{
	224	unwind_frame_run_internal ((char ) NULL, (char ) NULL);
	225	}
	226
	227	static void
	228	clear_unwind_protects_internal (flag, ignore)
	229	char flag, ignore;
	230	{
	231	if (flag)
	232	{
	233	while (unwind_protect_list)
	234	remove_unwind_protect_internal ((char )NULL, (char )NULL);
	235	}
	236	unwind_protect_list = (UNWIND_ELT *)NULL;
	237	}
	238
	239	static void
	240	unwind_frame_discard_internal (tag, ignore)
	241	char tag, ignore;
	242	{
	243	UNWIND_ELT *elt;
	244	int found;
	245
	246	found = 0;
	247	while (elt = unwind_protect_list)
	248	{
	249	unwind_protect_list = unwind_protect_list->head.next;
	250	if (elt->head.cleanup == 0 && (STREQ (elt->arg.v, tag)))
	251	{
	252	uwpfree (elt);
	253	found = 1;
	254	break;
	255	}
	256	else
	257	uwpfree (elt);
	258	}
	259
	260	if (found == 0)
	261	internal_warning ("unwind_frame_discard: %s: frame not found", tag);
	262	}
	263
	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. */
	267	static inline void
	268	restore_variable (sv)
	269	SAVED_VAR *sv;
	270	{
	271	FASTCOPY (sv->desired_setting, sv->variable, sv->size);
	272	}
	273
	274	static void
	275	unwind_frame_run_internal (tag, ignore)
	276	char tag, ignore;
	277	{
	278	UNWIND_ELT *elt;
	279	int found;
	280
	281	found = 0;
	282	while (elt = unwind_protect_list)
	283	{
	284	unwind_protect_list = elt->head.next;
	285
	286	/* If tag, then compare. */
	287	if (elt->head.cleanup == 0)
	288	{
	289	if (tag && STREQ (elt->arg.v, tag))
	290	{
	291	uwpfree (elt);
	292	found = 1;
	293	break;
	294	}
	295	}
	296	else
	297	{
	298	if (elt->head.cleanup == (Function *) restore_variable)
	299	restore_variable (&elt->sv.v);
	300	else
	301	(*(elt->head.cleanup)) (elt->arg.v);
	302	}
	303
	304	uwpfree (elt);
	305	}
	306	if (tag && found == 0)
	307	internal_warning ("unwind_frame_run: %s: frame not found", tag);
	308	}
	309
	310	static void
	311	unwind_protect_mem_internal (var, psize)
	312	char *var;
	313	char *psize;
	314	{
	315	int size, allocated;
	316	UNWIND_ELT *elt;
	317
	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;
	327	}
	328
	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
	331	bytes of VAR. */
	332	void
	333	unwind_protect_mem (var, size)
	334	char *var;
	335	int size;
	336	{
	337	without_interrupts (unwind_protect_mem_internal, var, (char *) &size);
	338	}
	339
	340	#if defined (DEBUG)
	341	#include <stdio.h>
	342
	343	void
	344	print_unwind_protect_tags ()
	345	{
	346	UNWIND_ELT *elt;
	347
	348	elt = unwind_protect_list;
	349	while (elt)
	350	{
	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;
	355	}
	356	}
	357	#endif