[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 "sig.h"
#include "quit.h"
#include "error.h"	/* for internal_warning */
#include "ocache.h"

/* 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;

/* Allocating from a cache of unwind-protect elements */
#define UWCACHESIZE	128

sh_obj_cache_t uwcache = {0, 0, 0};

#if 0
#define uwpalloc(elt)	(elt) = (UNWIND_ELT *)xmalloc (sizeof (UNWIND_ELT))
#define uwpfree(elt)	free(elt)
#else
#define uwpalloc(elt)	ocache_alloc (uwcache, UNWIND_ELT, elt)
#define uwpfree(elt)	ocache_free (uwcache, UNWIND_ELT, elt)
#endif

void
uwp_init ()
{
  ocache_create (uwcache, UNWIND_ELT, UWCACHESIZE);
}

/* 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);
}

int
unwind_protect_tag_on_stack (tag)
     const char *tag;
{
  UNWIND_ELT *elt;

  elt = unwind_protect_list;
  while (elt)
    {
      if (elt->head.cleanup == 0 && STREQ (elt->arg.v, tag))
	return 1;
      elt = elt->head.next;
    }
  return 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)
    {
      if (elt->head.cleanup == 0)
        fprintf(stderr, "tag: %s\n", elt->arg.v);
      elt = elt->head.next;
    }
}
#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 "sig.h"
	50	#include "quit.h"
	51	#include "error.h" /* for internal_warning */
	52	#include "ocache.h"
	53
	54	/* Structure describing a saved variable and the value to restore it to. */
	55	typedef struct {
	56	char *variable;
	57	int size;
	58	char desired_setting[1]; /* actual size is `size' */
	59	} SAVED_VAR;
	60
	61	/* If HEAD.CLEANUP is null, then ARG.V contains a tag to throw back to.
	62	If HEAD.CLEANUP is restore_variable, then SV.V contains the saved
	63	variable. Otherwise, call HEAD.CLEANUP (ARG.V) to clean up. */
	64	typedef union uwp {
	65	struct uwp_head {
	66	union uwp *next;
	67	Function *cleanup;
	68	} head;
	69	struct {
	70	struct uwp_head uwp_head;
	71	char *v;
	72	} arg;
	73	struct {
	74	struct uwp_head uwp_head;
	75	SAVED_VAR v;
	76	} sv;
	77	} UNWIND_ELT;
	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	/* Allocating from a cache of unwind-protect elements */
	92	#define UWCACHESIZE 128
	93
	94	sh_obj_cache_t uwcache = {0, 0, 0};
	95
	96	#if 0
	97	#define uwpalloc(elt) (elt) = (UNWIND_ELT *)xmalloc (sizeof (UNWIND_ELT))
	98	#define uwpfree(elt) free(elt)
	99	#else
	100	#define uwpalloc(elt) ocache_alloc (uwcache, UNWIND_ELT, elt)
	101	#define uwpfree(elt) ocache_free (uwcache, UNWIND_ELT, elt)
	102	#endif
	103
	104	void
	105	uwp_init ()
	106	{
	107	ocache_create (uwcache, UNWIND_ELT, UWCACHESIZE);
	108	}
	109
	110	/* Run a function without interrupts. This relies on the fact that the
	111	FUNCTION cannot change the value of interrupt_immediately. (I.e., does
	112	not call QUIT (). */
	113	static void
	114	without_interrupts (function, arg1, arg2)
	115	VFunction *function;
	116	char arg1, arg2;
	117	{
	118	int old_interrupt_immediately;
	119
	120	old_interrupt_immediately = interrupt_immediately;
	121	interrupt_immediately = 0;
	122
	123	(*function)(arg1, arg2);
	124
	125	interrupt_immediately = old_interrupt_immediately;
	126	}
	127
	128	/* Start the beginning of a region. */
	129	void
	130	begin_unwind_frame (tag)
	131	char *tag;
	132	{
	133	add_unwind_protect ((Function *)NULL, tag);
	134	}
	135
	136	/* Discard the unwind protects back to TAG. */
	137	void
	138	discard_unwind_frame (tag)
	139	char *tag;
	140	{
	141	if (unwind_protect_list)
	142	without_interrupts (unwind_frame_discard_internal, tag, (char *)NULL);
	143	}
	144
	145	/* Run the unwind protects back to TAG. */
	146	void
	147	run_unwind_frame (tag)
	148	char *tag;
	149	{
	150	if (unwind_protect_list)
	151	without_interrupts (unwind_frame_run_internal, tag, (char *)NULL);
	152	}
	153
	154	/* Add the function CLEANUP with ARG to the list of unwindable things. */
	155	void
	156	add_unwind_protect (cleanup, arg)
	157	Function *cleanup;
	158	char *arg;
	159	{
	160	without_interrupts (add_unwind_protect_internal, (char *)cleanup, arg);
	161	}
	162
	163	/* Remove the top unwind protect from the list. */
	164	void
	165	remove_unwind_protect ()
	166	{
	167	if (unwind_protect_list)
	168	without_interrupts
	169	(remove_unwind_protect_internal, (char )NULL, (char )NULL);
	170	}
	171
	172	/* Run the list of cleanup functions in unwind_protect_list. */
	173	void
	174	run_unwind_protects ()
	175	{
	176	if (unwind_protect_list)
	177	without_interrupts
	178	(run_unwind_protects_internal, (char )NULL, (char )NULL);
	179	}
	180
	181	/* Erase the unwind-protect list. If flags is 1, free the elements. */
	182	void
	183	clear_unwind_protect_list (flags)
	184	int flags;
	185	{
	186	char *flag;
	187
	188	if (unwind_protect_list)
	189	{
	190	flag = flags ? "" : (char *)NULL;
	191	without_interrupts
	192	(clear_unwind_protects_internal, flag, (char *)NULL);
	193	}
	194	}
	195
	196	int
	197	have_unwind_protects ()
	198	{
	199	return (unwind_protect_list != 0);
	200	}
	201
	202	int
	203	unwind_protect_tag_on_stack (tag)
	204	const char *tag;
	205	{
	206	UNWIND_ELT *elt;
	207
	208	elt = unwind_protect_list;
	209	while (elt)
	210	{
	211	if (elt->head.cleanup == 0 && STREQ (elt->arg.v, tag))
	212	return 1;
	213	elt = elt->head.next;
	214	}
	215	return 0;
	216	}
	217
	218	/* **************************************************************** */
	219	/* */
	220	/* The Actual Functions */
	221	/* */
	222	/* **************************************************************** */
	223
	224	static void
	225	add_unwind_protect_internal (cleanup, arg)
	226	Function *cleanup;
	227	char *arg;
	228	{
	229	UNWIND_ELT *elt;
	230
	231	uwpalloc (elt);
	232	elt->head.next = unwind_protect_list;
	233	elt->head.cleanup = cleanup;
	234	elt->arg.v = arg;
	235	unwind_protect_list = elt;
	236	}
	237
	238	static void
	239	remove_unwind_protect_internal (ignore1, ignore2)
	240	char ignore1, ignore2;
	241	{
	242	UNWIND_ELT *elt;
	243
	244	elt = unwind_protect_list;
	245	if (elt)
	246	{
	247	unwind_protect_list = unwind_protect_list->head.next;
	248	uwpfree (elt);
	249	}
	250	}
	251
	252	static void
	253	run_unwind_protects_internal (ignore1, ignore2)
	254	char ignore1, ignore2;
	255	{
	256	unwind_frame_run_internal ((char ) NULL, (char ) NULL);
	257	}
	258
	259	static void
	260	clear_unwind_protects_internal (flag, ignore)
	261	char flag, ignore;
	262	{
	263	if (flag)
	264	{
	265	while (unwind_protect_list)
	266	remove_unwind_protect_internal ((char )NULL, (char )NULL);
	267	}
	268	unwind_protect_list = (UNWIND_ELT *)NULL;
	269	}
	270
	271	static void
	272	unwind_frame_discard_internal (tag, ignore)
	273	char tag, ignore;
	274	{
	275	UNWIND_ELT *elt;
	276	int found;
	277
	278	found = 0;
	279	while (elt = unwind_protect_list)
	280	{
	281	unwind_protect_list = unwind_protect_list->head.next;
	282	if (elt->head.cleanup == 0 && (STREQ (elt->arg.v, tag)))
	283	{
	284	uwpfree (elt);
	285	found = 1;
	286	break;
	287	}
	288	else
	289	uwpfree (elt);
	290	}
	291
	292	if (found == 0)
	293	internal_warning ("unwind_frame_discard: %s: frame not found", tag);
	294	}
	295
	296	/* Restore the value of a variable, based on the contents of SV.
	297	sv->desired_setting is a block of memory SIZE bytes long holding the
	298	value itself. This block of memory is copied back into the variable. */
	299	static inline void
	300	restore_variable (sv)
	301	SAVED_VAR *sv;
	302	{
	303	FASTCOPY (sv->desired_setting, sv->variable, sv->size);
	304	}
	305
	306	static void
	307	unwind_frame_run_internal (tag, ignore)
	308	char tag, ignore;
	309	{
	310	UNWIND_ELT *elt;
	311	int found;
	312
	313	found = 0;
	314	while (elt = unwind_protect_list)
	315	{
	316	unwind_protect_list = elt->head.next;
	317
	318	/* If tag, then compare. */
	319	if (elt->head.cleanup == 0)
	320	{
	321	if (tag && STREQ (elt->arg.v, tag))
	322	{
	323	uwpfree (elt);
	324	found = 1;
	325	break;
	326	}
	327	}
	328	else
	329	{
	330	if (elt->head.cleanup == (Function *) restore_variable)
	331	restore_variable (&elt->sv.v);
	332	else
	333	(*(elt->head.cleanup)) (elt->arg.v);
	334	}
	335
	336	uwpfree (elt);
	337	}
	338	if (tag && found == 0)
	339	internal_warning ("unwind_frame_run: %s: frame not found", tag);
	340	}
	341
	342	static void
	343	unwind_protect_mem_internal (var, psize)
	344	char *var;
	345	char *psize;
	346	{
	347	int size, allocated;
	348	UNWIND_ELT *elt;
	349
	350	size = (int ) psize;
	351	allocated = size + offsetof (UNWIND_ELT, sv.v.desired_setting[0]);
	352	elt = (UNWIND_ELT *)xmalloc (allocated);
	353	elt->head.next = unwind_protect_list;
	354	elt->head.cleanup = (Function *) restore_variable;
	355	elt->sv.v.variable = var;
	356	elt->sv.v.size = size;
	357	FASTCOPY (var, elt->sv.v.desired_setting, size);
	358	unwind_protect_list = elt;
	359	}
	360
	361	/* Save the value of a variable so it will be restored when unwind-protects
	362	are run. VAR is a pointer to the variable. SIZE is the size in
	363	bytes of VAR. */
	364	void
	365	unwind_protect_mem (var, size)
	366	char *var;
	367	int size;
	368	{
	369	without_interrupts (unwind_protect_mem_internal, var, (char *) &size);
	370	}
	371
	372	#if defined (DEBUG)
	373	#include <stdio.h>
	374
	375	void
	376	print_unwind_protect_tags ()
	377	{
	378	UNWIND_ELT *elt;
	379
	380	elt = unwind_protect_list;
	381	while (elt)
	382	{
	383	if (elt->head.cleanup == 0)
	384	fprintf(stderr, "tag: %s\n", elt->arg.v);
	385	elt = elt->head.next;
	386	}
	387	}
	388	#endif