[thirdparty/bash.git] / builtins / enable.def

This file is enable.def, from which is created enable.c.
It implements the builtin "enable" in Bash.

Copyright (C) 1987, 1989, 1991 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 2, 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; see the file COPYING.  If not, write to the Free Software
Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA.

$PRODUCES enable.c

$BUILTIN enable
$FUNCTION enable_builtin
$SHORT_DOC enable [-pnds] [-a] [-f filename] [name ...]
Enable and disable builtin shell commands.  This allows
you to use a disk command which has the same name as a shell
builtin without specifying a full pathname.  If -n is used, the
NAMEs become disabled; otherwise NAMEs are enabled.  For example,
to use the `test' found in $PATH instead of the shell builtin
version, type `enable -n test'.  On systems supporting dynamic
loading, the -f option may be used to load new builtins from the
shared object FILENAME.  The -d option will delete a builtin
previously loaded with -f.  If no non-option names are given, or
the -p option is supplied, a list of builtins is printed.  The
-a option means to print every builtin with an indication of whether
or not it is enabled.  The -s option restricts the output to the POSIX.2
`special' builtins.  The -n option displays a list of all disabled builtins.
$END

#include <config.h>

#if defined (HAVE_UNISTD_H)
#  ifdef _MINIX
#    include <sys/types.h>
#  endif
#  include <unistd.h>
#endif

#include <stdio.h>
#include "../bashansi.h"
#include "../shell.h"
#include "../builtins.h"
#include "../flags.h"
#include "common.h"
#include "bashgetopt.h"

#if defined (PROGRAMMABLE_COMPLETION)
#  include "../pcomplete.h"
#endif

#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
static int dyn_load_builtin ();
#endif

#if defined (HAVE_DLCLOSE)
static int dyn_unload_builtin ();
#endif

#define ENABLED  1
#define DISABLED 2
#define SPECIAL  4

#define AFLAG	0x01
#define DFLAG	0x02
#define FFLAG	0x04
#define NFLAG	0x08
#define PFLAG	0x10
#define SFLAG	0x20

static int enable_shell_command ();
static void list_some_builtins ();

/* Enable/disable shell commands present in LIST.  If list is not specified,
   then print out a list of shell commands showing which are enabled and
   which are disabled. */
int
enable_builtin (list)
     WORD_LIST *list;
{
  int result, flags;
  int opt, filter;
#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
  char *filename;
#endif

  result = EXECUTION_SUCCESS;
  flags = 0;

  reset_internal_getopt ();
  while ((opt = internal_getopt (list, "adnpsf:")) != -1)
    {
      switch (opt)
	{
	case 'a':
	  flags |= AFLAG;
	  break;
	case 'n':
	  flags |= NFLAG;
	  break;
	case 'p':
	  flags |= PFLAG;
	  break;
	case 's':
	  flags |= SFLAG;
	  break;
	case 'f':
#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
	  flags |= FFLAG;
	  filename = list_optarg;
	  break;
#else
	  builtin_error ("dynamic loading not available");
	  return (EX_USAGE);
#endif
#if defined (HAVE_DLCLOSE)
	case 'd':
	  flags |= DFLAG;
	  break;
#else
	  builtin_error ("dynamic loading not available");
	  return (EX_USAGE);
#endif /* HAVE_DLCLOSE */
	default:
	  builtin_usage ();
	  return (EX_USAGE);
	}
    }

  list = loptend;

#if defined (RESTRICTED_SHELL)
  /* Restricted shells cannot load new builtins. */
  if (restricted && (flags & (FFLAG|DFLAG)))
    {
      builtin_error ("restricted");
      return (EXECUTION_FAILURE);
    }
#endif

  if (list == 0 || (flags & PFLAG))
    {
      filter = (flags & AFLAG) ? (ENABLED | DISABLED)
			       : (flags & NFLAG) ? DISABLED : ENABLED;

      if (flags & SFLAG)
	filter |= SPECIAL;

      list_some_builtins (filter);
    }
#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
  else if (flags & FFLAG)
    {
      filter = (flags & NFLAG) ? DISABLED : ENABLED;
      if (flags & SFLAG)
	filter |= SPECIAL;

      result = dyn_load_builtin (list, filter, filename);
#if defined (PROGRAMMABLE_COMPLETION)
      set_itemlist_dirty (&it_builtins);
#endif
    }
#endif
#if defined (HAVE_DLCLOSE)
  else if (flags & DFLAG)
    {
      while (list)
	{
	  opt = dyn_unload_builtin (list->word->word);
	  if (opt == EXECUTION_FAILURE)
	    result = EXECUTION_FAILURE;
	  list = list->next;
	}
#if defined (PROGRAMMABLE_COMPLETION)
      set_itemlist_dirty (&it_builtins);
#endif
    }
#endif
  else
    {
      while (list)
	{
	  opt = enable_shell_command (list->word->word, flags & NFLAG);

	  if (opt == EXECUTION_FAILURE)
	    {
	      builtin_error ("%s: not a shell builtin", list->word->word);
	      result = EXECUTION_FAILURE;
	    }
	  list = list->next;
	}
    }
  return (result);
}

/* List some builtins.
   FILTER is a mask with two slots: ENABLED and DISABLED. */
static void
list_some_builtins (filter)
     int filter;
{
  register int i;

  for (i = 0; i < num_shell_builtins; i++)
    {
      if (shell_builtins[i].function == 0 || (shell_builtins[i].flags & BUILTIN_DELETED))
	continue;

      if ((filter & SPECIAL) &&
	  (shell_builtins[i].flags & SPECIAL_BUILTIN) == 0)
	continue;

      if ((filter & ENABLED) && (shell_builtins[i].flags & BUILTIN_ENABLED))
	printf ("enable %s\n", shell_builtins[i].name);
      else if ((filter & DISABLED) &&
	       ((shell_builtins[i].flags & BUILTIN_ENABLED) == 0))
	printf ("enable -n %s\n", shell_builtins[i].name);
    }
}

/* Enable the shell command NAME.  If DISABLE_P is non-zero, then
   disable NAME instead. */
static int
enable_shell_command (name, disable_p)
     char *name;
     int disable_p;
{
  struct builtin *b;

  b = builtin_address_internal (name, 1);
  if (b == 0)
    return (EXECUTION_FAILURE);

  if (disable_p)
    b->flags &= ~BUILTIN_ENABLED;
  else
    b->flags |= BUILTIN_ENABLED;

#if defined (PROGRAMMABLE_COMPLETION)
  set_itemlist_dirty (&it_enabled);
  set_itemlist_dirty (&it_disabled);
#endif

  return (EXECUTION_SUCCESS);
}

#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)

#if defined (HAVE_DLFCN_H)
#  include <dlfcn.h>
#endif

static int
dyn_load_builtin (list, flags, filename)
     WORD_LIST *list;
     int flags;
     char *filename;
{
  WORD_LIST *l;
  void *handle;
  
  int total, size, new, replaced;
  char *struct_name, *name;
  struct builtin **new_builtins, *b, *new_shell_builtins, *old_builtin;

  if (list == 0)
    return (EXECUTION_FAILURE);

#ifndef RTLD_LAZY
#define RTLD_LAZY 1
#endif

#if defined (_AIX)
  handle = dlopen (filename, RTLD_NOW|RTLD_GLOBAL);
#else
  handle = dlopen (filename, RTLD_LAZY);
#endif /* !_AIX */

  if (handle == 0)
    {
      builtin_error ("cannot open shared object %s: %s", filename, dlerror ());
      return (EXECUTION_FAILURE);
    }

  for (new = 0, l = list; l; l = l->next, new++)
    ;
  new_builtins = (struct builtin **)xmalloc (new * sizeof (struct builtin *));

  /* For each new builtin in the shared object, find it and its describing
     structure.  If this is overwriting an existing builtin, do so, otherwise
     save the loaded struct for creating the new list of builtins. */
  for (replaced = new = 0; list; list = list->next)
    {
      name = list->word->word;

      size = strlen (name);
      struct_name = xmalloc (size + 8);
      strcpy (struct_name, name);
      strcpy (struct_name + size, "_struct");

      b = (struct builtin *)dlsym (handle, struct_name);
      if (b == 0)
	{
	  builtin_error ("cannot find %s in shared object %s: %s", struct_name,
			  filename, dlerror ());
	  free (struct_name);
	  continue;
	}

      free (struct_name);

      b->flags &= ~STATIC_BUILTIN;
      if (flags & SPECIAL)
	b->flags |= SPECIAL_BUILTIN;
      b->handle = handle;

      if (old_builtin = builtin_address_internal (name, 1))
	{
	  replaced++;
	  FASTCOPY ((char *)b, (char *)old_builtin, sizeof (struct builtin));
	}
      else
	  new_builtins[new++] = b;
    }

  if (replaced == 0 && new == 0)
    {
      free (new_builtins);
      dlclose (handle);
      return (EXECUTION_FAILURE);
    }

  if (new)
    {
      total = num_shell_builtins + new;
      size = (total + 1) * sizeof (struct builtin);

      new_shell_builtins = (struct builtin *)xmalloc (size);
      FASTCOPY ((char *)shell_builtins, (char *)new_shell_builtins,
		num_shell_builtins * sizeof (struct builtin));
      for (replaced = 0; replaced < new; replaced++)
	FASTCOPY ((char *)new_builtins[replaced],
		  (char *)&new_shell_builtins[num_shell_builtins + replaced],
		  sizeof (struct builtin));

      new_shell_builtins[total].name = (char *)0;
      new_shell_builtins[total].function = (Function *)0;
      new_shell_builtins[total].flags = 0;

      if (shell_builtins != static_shell_builtins)
	free (shell_builtins);

      shell_builtins = new_shell_builtins;
      num_shell_builtins = total;
      initialize_shell_builtins ();
    }

  free (new_builtins);
  return (EXECUTION_SUCCESS);
}
#endif

#if defined (HAVE_DLCLOSE)
static void
delete_builtin (b)
     struct builtin *b;
{
  int ind, size;
  struct builtin *new_shell_builtins;

  /* XXX - funky pointer arithmetic - XXX */
#ifdef __STDC__
  ind = b - shell_builtins;
#else
  ind = ((int)b - (int)shell_builtins) / sizeof (struct builtin);
#endif
  size = num_shell_builtins * sizeof (struct builtin);
  new_shell_builtins = (struct builtin *)xmalloc (size);

  /* Copy shell_builtins[0]...shell_builtins[ind - 1] to new_shell_builtins */
  if (ind)
    FASTCOPY ((char *)shell_builtins, (char *)new_shell_builtins,
	      ind * sizeof (struct builtin));
  /* Copy shell_builtins[ind+1]...shell_builtins[num_shell_builtins to
     new_shell_builtins, starting at ind. */
  FASTCOPY ((char *)(&shell_builtins[ind+1]),
  	    (char *)(&new_shell_builtins[ind]),
  	    (num_shell_builtins - ind) * sizeof (struct builtin));

  if (shell_builtins != static_shell_builtins)
    free (shell_builtins);

  /* The result is still sorted. */
  num_shell_builtins--;
  shell_builtins = new_shell_builtins;
}

/* Tenon's MachTen has a dlclose that doesn't return a value, so we
   finesse it with a local wrapper. */
static int
local_dlclose (handle)
     void *handle;
{
#if !defined (__MACHTEN__)
  return (dlclose (handle));
#else /* __MACHTEN__ */
  dlclose (handle);
  return ((dlerror () != NULL) ? -1 : 0);    
#endif /* __MACHTEN__ */
}

static int
dyn_unload_builtin (name)
     char *name;
{
  struct builtin *b;
  void *handle;
  int ref, i;
  char *uerror;

  b = builtin_address_internal (name, 1);
  if (b == 0)
    {
      builtin_error ("%s: not a shell builtin", name);
      return (EXECUTION_FAILURE);
    }
  if (b->flags & STATIC_BUILTIN)
    {
      builtin_error ("%s: not dynamically loaded", name);
      return (EXECUTION_FAILURE);
    }

  handle = (void *)b->handle;
  for (ref = i = 0; i < num_shell_builtins; i++)
    {
      if (shell_builtins[i].handle == b->handle)
	ref++;
    }

  /* Don't remove the shared object unless the reference count of builtins
     using it drops to zero. */
  if (ref == 1 && local_dlclose (handle) != 0)
    {
      builtin_error ("cannot delete %s: %s", name, dlerror ());
      return (EXECUTION_FAILURE);
    }

  /* Now remove this entry from the builtin table and reinitialize. */
  delete_builtin (b);

  return (EXECUTION_SUCCESS);
}
#endif
Commit	Line	Data
726f6388 JA	1	This file is enable.def, from which is created enable.c.
	2	It implements the builtin "enable" in Bash.
	3
	4	Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
	5
	6	This file is part of GNU Bash, the Bourne Again SHell.
	7
	8	Bash is free software; you can redistribute it and/or modify it under
	9	the terms of the GNU General Public License as published by the Free
bb70624e	10	Software Foundation; either version 2, or (at your option) any later
726f6388 JA	11	version.
	12
	13	Bash is distributed in the hope that it will be useful, but WITHOUT ANY
	14	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	16	for more details.
	17
	18	You should have received a copy of the GNU General Public License along
	19	with Bash; see the file COPYING. If not, write to the Free Software
bb70624e	20	Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA.
726f6388 JA	21
	22	$PRODUCES enable.c
	23
	24	$BUILTIN enable
	25	$FUNCTION enable_builtin
ccc6cda3	26	$SHORT_DOC enable [-pnds] [-a] [-f filename] [name ...]
726f6388 JA	27	Enable and disable builtin shell commands. This allows
726f6388 JA	28	you to use a disk command which has the same name as a shell
b72432fd JA	29	builtin without specifying a full pathname. If -n is used, the
	30	NAMEs become disabled; otherwise NAMEs are enabled. For example,
	31	to use the `test' found in $PATH instead of the shell builtin
	32	version, type `enable -n test'. On systems supporting dynamic
	33	loading, the -f option may be used to load new builtins from the
	34	shared object FILENAME. The -d option will delete a builtin
	35	previously loaded with -f. If no non-option names are given, or
	36	the -p option is supplied, a list of builtins is printed. The
	37	-a option means to print every builtin with an indication of whether
	38	or not it is enabled. The -s option restricts the output to the POSIX.2
	39	`special' builtins. The -n option displays a list of all disabled builtins.
726f6388 JA	40	$END
726f6388 JA	41
ccc6cda3 JA	42	#include <config.h>
	43
	44	#if defined (HAVE_UNISTD_H)
cce855bc JA	45	# ifdef _MINIX
	46	# include <sys/types.h>
	47	# endif
ccc6cda3 JA	48	# include <unistd.h>
	49	#endif
	50
	51	#include <stdio.h>
	52	#include "../bashansi.h"
726f6388 JA	53	#include "../shell.h"
726f6388 JA	54	#include "../builtins.h"
ccc6cda3	55	#include "../flags.h"
726f6388	56	#include "common.h"
ccc6cda3 JA	57	#include "bashgetopt.h"
ccc6cda3 JA	58
bb70624e JA	59	#if defined (PROGRAMMABLE_COMPLETION)
	60	# include "../pcomplete.h"
	61	#endif
	62
ccc6cda3 JA	63	#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
	64	static int dyn_load_builtin ();
	65	#endif
	66
	67	#if defined (HAVE_DLCLOSE)
	68	static int dyn_unload_builtin ();
	69	#endif
726f6388 JA	70
	71	#define ENABLED 1
	72	#define DISABLED 2
ccc6cda3 JA	73	#define SPECIAL 4
	74
	75	#define AFLAG 0x01
	76	#define DFLAG 0x02
	77	#define FFLAG 0x04
	78	#define NFLAG 0x08
	79	#define PFLAG 0x10
	80	#define SFLAG 0x20
726f6388 JA	81
	82	static int enable_shell_command ();
	83	static void list_some_builtins ();
	84
	85	/* Enable/disable shell commands present in LIST. If list is not specified,
	86	then print out a list of shell commands showing which are enabled and
	87	which are disabled. */
ccc6cda3	88	int
726f6388 JA	89	enable_builtin (list)
	90	WORD_LIST *list;
	91	{
ccc6cda3 JA	92	int result, flags;
	93	int opt, filter;
	94	#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
	95	char *filename;
	96	#endif
726f6388	97
ccc6cda3 JA	98	result = EXECUTION_SUCCESS;
ccc6cda3 JA	99	flags = 0;
726f6388	100
ccc6cda3 JA	101	reset_internal_getopt ();
ccc6cda3 JA	102	while ((opt = internal_getopt (list, "adnpsf:")) != -1)
726f6388	103	{
ccc6cda3	104	switch (opt)
726f6388	105	{
ccc6cda3 JA	106	case 'a':
	107	flags \|= AFLAG;
	108	break;
	109	case 'n':
	110	flags \|= NFLAG;
	111	break;
	112	case 'p':
	113	flags \|= PFLAG;
	114	break;
	115	case 's':
	116	flags \|= SFLAG;
	117	break;
	118	case 'f':
	119	#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
	120	flags \|= FFLAG;
	121	filename = list_optarg;
	122	break;
	123	#else
	124	builtin_error ("dynamic loading not available");
	125	return (EX_USAGE);
	126	#endif
	127	#if defined (HAVE_DLCLOSE)
	128	case 'd':
	129	flags \|= DFLAG;
	130	break;
	131	#else
	132	builtin_error ("dynamic loading not available");
	133	return (EX_USAGE);
	134	#endif /* HAVE_DLCLOSE */
	135	default:
	136	builtin_usage ();
	137	return (EX_USAGE);
726f6388 JA	138	}
	139	}
	140
ccc6cda3 JA	141	list = loptend;
	142
	143	#if defined (RESTRICTED_SHELL)
	144	/* Restricted shells cannot load new builtins. */
	145	if (restricted && (flags & (FFLAG\|DFLAG)))
726f6388	146	{
ccc6cda3 JA	147	builtin_error ("restricted");
	148	return (EXECUTION_FAILURE);
	149	}
	150	#endif
726f6388	151
ccc6cda3 JA	152	if (list == 0 \|\| (flags & PFLAG))
	153	{
	154	filter = (flags & AFLAG) ? (ENABLED \| DISABLED)
	155	: (flags & NFLAG) ? DISABLED : ENABLED;
	156
	157	if (flags & SFLAG)
	158	filter \|= SPECIAL;
726f6388 JA	159
	160	list_some_builtins (filter);
	161	}
ccc6cda3 JA	162	#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
	163	else if (flags & FFLAG)
	164	{
	165	filter = (flags & NFLAG) ? DISABLED : ENABLED;
	166	if (flags & SFLAG)
28ef6c31	167	filter \|= SPECIAL;
ccc6cda3 JA	168
ccc6cda3 JA	169	result = dyn_load_builtin (list, filter, filename);
bb70624e JA	170	#if defined (PROGRAMMABLE_COMPLETION)
	171	set_itemlist_dirty (&it_builtins);
	172	#endif
ccc6cda3 JA	173	}
	174	#endif
	175	#if defined (HAVE_DLCLOSE)
	176	else if (flags & DFLAG)
	177	{
	178	while (list)
	179	{
	180	opt = dyn_unload_builtin (list->word->word);
	181	if (opt == EXECUTION_FAILURE)
	182	result = EXECUTION_FAILURE;
	183	list = list->next;
	184	}
bb70624e JA	185	#if defined (PROGRAMMABLE_COMPLETION)
	186	set_itemlist_dirty (&it_builtins);
	187	#endif
ccc6cda3 JA	188	}
ccc6cda3 JA	189	#endif
726f6388 JA	190	else
	191	{
	192	while (list)
	193	{
ccc6cda3	194	opt = enable_shell_command (list->word->word, flags & NFLAG);
726f6388	195
ccc6cda3	196	if (opt == EXECUTION_FAILURE)
726f6388 JA	197	{
726f6388 JA	198	builtin_error ("%s: not a shell builtin", list->word->word);
ccc6cda3	199	result = EXECUTION_FAILURE;
726f6388 JA	200	}
	201	list = list->next;
	202	}
	203	}
ccc6cda3	204	return (result);
726f6388 JA	205	}
	206
	207	/* List some builtins.
	208	FILTER is a mask with two slots: ENABLED and DISABLED. */
	209	static void
	210	list_some_builtins (filter)
	211	int filter;
	212	{
	213	register int i;
	214
	215	for (i = 0; i < num_shell_builtins; i++)
	216	{
ccc6cda3	217	if (shell_builtins[i].function == 0 \|\| (shell_builtins[i].flags & BUILTIN_DELETED))
726f6388 JA	218	continue;
726f6388 JA	219
ccc6cda3 JA	220	if ((filter & SPECIAL) &&
	221	(shell_builtins[i].flags & SPECIAL_BUILTIN) == 0)
	222	continue;
	223
	224	if ((filter & ENABLED) && (shell_builtins[i].flags & BUILTIN_ENABLED))
	225	printf ("enable %s\n", shell_builtins[i].name);
726f6388 JA	226	else if ((filter & DISABLED) &&
726f6388 JA	227	((shell_builtins[i].flags & BUILTIN_ENABLED) == 0))
ccc6cda3	228	printf ("enable -n %s\n", shell_builtins[i].name);
726f6388 JA	229	}
	230	}
	231
	232	/* Enable the shell command NAME. If DISABLE_P is non-zero, then
	233	disable NAME instead. */
	234	static int
	235	enable_shell_command (name, disable_p)
	236	char *name;
	237	int disable_p;
	238	{
ccc6cda3	239	struct builtin *b;
726f6388	240
ccc6cda3 JA	241	b = builtin_address_internal (name, 1);
	242	if (b == 0)
	243	return (EXECUTION_FAILURE);
	244
	245	if (disable_p)
	246	b->flags &= ~BUILTIN_ENABLED;
	247	else
	248	b->flags \|= BUILTIN_ENABLED;
	249
bb70624e JA	250	#if defined (PROGRAMMABLE_COMPLETION)
	251	set_itemlist_dirty (&it_enabled);
	252	set_itemlist_dirty (&it_disabled);
	253	#endif
	254
ccc6cda3 JA	255	return (EXECUTION_SUCCESS);
	256	}
	257
	258	#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
d166f048 JA	259
	260	#if defined (HAVE_DLFCN_H)
	261	# include <dlfcn.h>
	262	#endif
ccc6cda3 JA	263
	264	static int
	265	dyn_load_builtin (list, flags, filename)
	266	WORD_LIST *list;
	267	int flags;
	268	char *filename;
	269	{
	270	WORD_LIST *l;
	271	void *handle;
	272
	273	int total, size, new, replaced;
	274	char struct_name, name;
	275	struct builtin *new_builtins, b, new_shell_builtins, old_builtin;
	276
	277	if (list == 0)
	278	return (EXECUTION_FAILURE);
	279
	280	#ifndef RTLD_LAZY
	281	#define RTLD_LAZY 1
	282	#endif
	283
	284	#if defined (_AIX)
	285	handle = dlopen (filename, RTLD_NOW\|RTLD_GLOBAL);
	286	#else
	287	handle = dlopen (filename, RTLD_LAZY);
	288	#endif /* !_AIX */
	289
	290	if (handle == 0)
726f6388	291	{
ccc6cda3 JA	292	builtin_error ("cannot open shared object %s: %s", filename, dlerror ());
	293	return (EXECUTION_FAILURE);
	294	}
726f6388	295
ccc6cda3 JA	296	for (new = 0, l = list; l; l = l->next, new++)
	297	;
	298	new_builtins = (struct builtin *)xmalloc (new sizeof (struct builtin *));
726f6388	299
ccc6cda3 JA	300	/* For each new builtin in the shared object, find it and its describing
	301	structure. If this is overwriting an existing builtin, do so, otherwise
	302	save the loaded struct for creating the new list of builtins. */
	303	for (replaced = new = 0; list; list = list->next)
	304	{
	305	name = list->word->word;
	306
	307	size = strlen (name);
	308	struct_name = xmalloc (size + 8);
	309	strcpy (struct_name, name);
	310	strcpy (struct_name + size, "_struct");
	311
	312	b = (struct builtin *)dlsym (handle, struct_name);
	313	if (b == 0)
	314	{
	315	builtin_error ("cannot find %s in shared object %s: %s", struct_name,
	316	filename, dlerror ());
	317	free (struct_name);
	318	continue;
726f6388	319	}
ccc6cda3 JA	320
	321	free (struct_name);
	322
	323	b->flags &= ~STATIC_BUILTIN;
	324	if (flags & SPECIAL)
	325	b->flags \|= SPECIAL_BUILTIN;
	326	b->handle = handle;
	327
	328	if (old_builtin = builtin_address_internal (name, 1))
28ef6c31 JA	329	{
28ef6c31 JA	330	replaced++;
ccc6cda3	331	FASTCOPY ((char )b, (char )old_builtin, sizeof (struct builtin));
28ef6c31	332	}
ccc6cda3 JA	333	else
	334	new_builtins[new++] = b;
	335	}
	336
	337	if (replaced == 0 && new == 0)
	338	{
	339	free (new_builtins);
	340	dlclose (handle);
	341	return (EXECUTION_FAILURE);
726f6388	342	}
ccc6cda3 JA	343
	344	if (new)
	345	{
	346	total = num_shell_builtins + new;
	347	size = (total + 1) * sizeof (struct builtin);
	348
	349	new_shell_builtins = (struct builtin *)xmalloc (size);
	350	FASTCOPY ((char )shell_builtins, (char )new_shell_builtins,
	351	num_shell_builtins * sizeof (struct builtin));
	352	for (replaced = 0; replaced < new; replaced++)
	353	FASTCOPY ((char *)new_builtins[replaced],
	354	(char *)&new_shell_builtins[num_shell_builtins + replaced],
	355	sizeof (struct builtin));
	356
	357	new_shell_builtins[total].name = (char *)0;
	358	new_shell_builtins[total].function = (Function *)0;
	359	new_shell_builtins[total].flags = 0;
	360
	361	if (shell_builtins != static_shell_builtins)
	362	free (shell_builtins);
	363
	364	shell_builtins = new_shell_builtins;
	365	num_shell_builtins = total;
	366	initialize_shell_builtins ();
	367	}
	368
	369	free (new_builtins);
	370	return (EXECUTION_SUCCESS);
	371	}
	372	#endif
	373
	374	#if defined (HAVE_DLCLOSE)
	375	static void
	376	delete_builtin (b)
	377	struct builtin *b;
	378	{
	379	int ind, size;
	380	struct builtin *new_shell_builtins;
	381
	382	/* XXX - funky pointer arithmetic - XXX */
d166f048 JA	383	#ifdef __STDC__
	384	ind = b - shell_builtins;
	385	#else
ccc6cda3	386	ind = ((int)b - (int)shell_builtins) / sizeof (struct builtin);
d166f048	387	#endif
ccc6cda3 JA	388	size = num_shell_builtins * sizeof (struct builtin);
	389	new_shell_builtins = (struct builtin *)xmalloc (size);
	390
	391	/* Copy shell_builtins[0]...shell_builtins[ind - 1] to new_shell_builtins */
	392	if (ind)
	393	FASTCOPY ((char )shell_builtins, (char )new_shell_builtins,
	394	ind * sizeof (struct builtin));
	395	/* Copy shell_builtins[ind+1]...shell_builtins[num_shell_builtins to
	396	new_shell_builtins, starting at ind. */
	397	FASTCOPY ((char *)(&shell_builtins[ind+1]),
	398	(char *)(&new_shell_builtins[ind]),
	399	(num_shell_builtins - ind) * sizeof (struct builtin));
	400
	401	if (shell_builtins != static_shell_builtins)
	402	free (shell_builtins);
	403
	404	/* The result is still sorted. */
	405	num_shell_builtins--;
	406	shell_builtins = new_shell_builtins;
	407	}
	408
b72432fd JA	409	/* Tenon's MachTen has a dlclose that doesn't return a value, so we
	410	finesse it with a local wrapper. */
	411	static int
	412	local_dlclose (handle)
	413	void *handle;
	414	{
	415	#if !defined (__MACHTEN__)
	416	return (dlclose (handle));
	417	#else /* __MACHTEN__ */
	418	dlclose (handle);
	419	return ((dlerror () != NULL) ? -1 : 0);
	420	#endif /* __MACHTEN__ */
	421	}
	422
ccc6cda3 JA	423	static int
	424	dyn_unload_builtin (name)
	425	char *name;
	426	{
	427	struct builtin *b;
	428	void *handle;
	429	int ref, i;
b72432fd	430	char *uerror;
ccc6cda3 JA	431
	432	b = builtin_address_internal (name, 1);
	433	if (b == 0)
	434	{
	435	builtin_error ("%s: not a shell builtin", name);
	436	return (EXECUTION_FAILURE);
	437	}
	438	if (b->flags & STATIC_BUILTIN)
	439	{
	440	builtin_error ("%s: not dynamically loaded", name);
	441	return (EXECUTION_FAILURE);
	442	}
	443
	444	handle = (void *)b->handle;
	445	for (ref = i = 0; i < num_shell_builtins; i++)
	446	{
	447	if (shell_builtins[i].handle == b->handle)
	448	ref++;
	449	}
	450
	451	/* Don't remove the shared object unless the reference count of builtins
	452	using it drops to zero. */
b72432fd	453	if (ref == 1 && local_dlclose (handle) != 0)
ccc6cda3 JA	454	{
	455	builtin_error ("cannot delete %s: %s", name, dlerror ());
	456	return (EXECUTION_FAILURE);
	457	}
	458
	459	/* Now remove this entry from the builtin table and reinitialize. */
	460	delete_builtin (b);
	461
	462	return (EXECUTION_SUCCESS);
726f6388	463	}
ccc6cda3	464	#endif