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

This file is shopt.def, from which is created shopt.c.
It implements the Bash `shopt' builtin.

Copyright (C) 1994-2003 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 shopt.c

$BUILTIN shopt
$FUNCTION shopt_builtin
$SHORT_DOC shopt [-pqsu] [-o long-option] optname [optname...]
Toggle the values of variables controlling optional behavior.
The -s flag means to enable (set) each OPTNAME; the -u flag
unsets each OPTNAME.  The -q flag suppresses output; the exit
status indicates whether each OPTNAME is set or unset.  The -o
option restricts the OPTNAMEs to those defined for use with
`set -o'.  With no options, or with the -p option, a list of all
settable options is displayed, with an indication of whether or
not each is set.
$END

#include <config.h>

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

#include <stdio.h>

#include "../bashintl.h"

#include "../shell.h"
#include "../flags.h"
#include "common.h"
#include "bashgetopt.h"

#define UNSETOPT	0
#define SETOPT		1

#define OPTFMT		"%-15s\t%s\n"

extern int allow_null_glob_expansion, fail_glob_expansion, glob_dot_filenames;
extern int cdable_vars, mail_warning, source_uses_path;
extern int no_exit_on_failed_exec, print_shift_error;
extern int check_hashed_filenames, promptvars;
extern int cdspelling, expand_aliases;
extern int extended_quote;
extern int check_window_size;
extern int glob_ignore_case;
extern int hup_on_exit;
extern int xpg_echo;
extern int gnu_error_format;

#if defined (EXTENDED_GLOB)
extern int extended_glob;
#endif

#if defined (HISTORY)
extern int literal_history, command_oriented_history;
extern int force_append_history;
#endif

#if defined (READLINE)
extern int hist_verify, history_reediting, perform_hostname_completion;
extern int no_empty_command_completion;
extern int force_fignore;
extern int enable_hostname_completion __P((int));
#endif

#if defined (PROGRAMMABLE_COMPLETION)
extern int prog_completion_enabled;
#endif

#if defined (RESTRICTED_SHELL)
extern char *shell_name;
#endif

#if defined (DEBUGGER)
extern int debugging_mode;
#endif

static void shopt_error __P((char *));

static int set_shellopts_after_change __P((int));

#if defined (RESTRICTED_SHELL)
static int set_restricted_shell __P((int));
#endif

static int shopt_login_shell;

typedef int shopt_set_func_t __P((int));

static struct {
  char *name;
  int  *value;
  shopt_set_func_t *set_func;
} shopt_vars[] = {
  { "cdable_vars", &cdable_vars, (shopt_set_func_t *)NULL },
  { "cdspell", &cdspelling, (shopt_set_func_t *)NULL },
  { "checkhash", &check_hashed_filenames, (shopt_set_func_t *)NULL },
  { "checkwinsize", &check_window_size, (shopt_set_func_t *)NULL },
#if defined (HISTORY)
  { "cmdhist", &command_oriented_history, (shopt_set_func_t *)NULL },
#endif
  { "dotglob", &glob_dot_filenames, (shopt_set_func_t *)NULL },
  { "execfail", &no_exit_on_failed_exec, (shopt_set_func_t *)NULL },
  { "expand_aliases", &expand_aliases, (shopt_set_func_t *)NULL },
#if defined (DEBUGGER)
  { "extdebug", &debugging_mode, (shopt_set_func_t *)NULL },
#endif
#if defined (EXTENDED_GLOB)
  { "extglob", &extended_glob, (shopt_set_func_t *)NULL },
#endif
  { "extquote", &extended_quote, (shopt_set_func_t *)NULL },
  { "failglob", &fail_glob_expansion, (shopt_set_func_t *)NULL },
#if defined (READLINE)
  { "force_fignore", &force_fignore, (shopt_set_func_t *)NULL },
  { "gnu_errfmt", &gnu_error_format, (shopt_set_func_t *)NULL },
  { "histreedit", &history_reediting, (shopt_set_func_t *)NULL },
#endif
#if defined (HISTORY)
  { "histappend", &force_append_history, (shopt_set_func_t *)NULL },
#endif
#if defined (READLINE)
  { "histverify", &hist_verify, (shopt_set_func_t *)NULL },
  { "hostcomplete", &perform_hostname_completion, enable_hostname_completion },
#endif
  { "huponexit", &hup_on_exit, (shopt_set_func_t *)NULL },
  { "interactive_comments", &interactive_comments, set_shellopts_after_change },
#if defined (HISTORY)
  { "lithist", &literal_history, (shopt_set_func_t *)NULL },
#endif
  { "login_shell", &shopt_login_shell, set_login_shell },
  { "mailwarn", &mail_warning, (shopt_set_func_t *)NULL },
#if defined (READLINE)
  { "no_empty_cmd_completion", &no_empty_command_completion, (shopt_set_func_t *)NULL },
#endif
  { "nocaseglob", &glob_ignore_case, (shopt_set_func_t *)NULL },
  { "nullglob",	&allow_null_glob_expansion, (shopt_set_func_t *)NULL },
#if defined (PROGRAMMABLE_COMPLETION)
  { "progcomp", &prog_completion_enabled, (shopt_set_func_t *)NULL },
#endif
  { "promptvars", &promptvars, (shopt_set_func_t *)NULL },
#if defined (RESTRICTED_SHELL)
  { "restricted_shell", &restricted_shell, set_restricted_shell },
#endif
  { "shift_verbose", &print_shift_error, (shopt_set_func_t *)NULL },
  { "sourcepath", &source_uses_path, (shopt_set_func_t *)NULL },
  { "xpg_echo", &xpg_echo, (shopt_set_func_t *)NULL },
  { (char *)0, (int *)0, (shopt_set_func_t *)NULL }
};

static char *on = "on";
static char *off = "off";

static int find_shopt __P((char *));
static int toggle_shopts __P((int, WORD_LIST *, int));
static void print_shopt __P((char *, int, int));
static int list_shopts __P((WORD_LIST *, int));
static int list_some_shopts __P((int, int));
static int list_shopt_o_options __P((WORD_LIST *, int));
static int list_some_o_options __P((int, int));
static int set_shopt_o_options __P((int, WORD_LIST *, int));

#define SFLAG	0x01
#define UFLAG	0x02
#define QFLAG	0x04
#define OFLAG	0x08
#define PFLAG	0x10

int
shopt_builtin (list)
     WORD_LIST *list;
{
  int opt, flags, rval;

  flags = 0;
  reset_internal_getopt ();
  while ((opt = internal_getopt (list, "psuoq")) != -1)
    {
      switch (opt)
	{
	case 's':
	  flags |= SFLAG;
	  break;
	case 'u':
	  flags |= UFLAG;
	  break;
	case 'q':
	  flags |= QFLAG;
	  break;
	case 'o':
	  flags |= OFLAG;
	  break;
	case 'p':
	  flags |= PFLAG;
	  break;
	default:
	  builtin_usage ();
	  return (EX_USAGE);
	}
    }
  list = loptend;

  if ((flags & (SFLAG|UFLAG)) == (SFLAG|UFLAG))
    {
      builtin_error (_("cannot set and unset shell options simultaneously"));
      return (EXECUTION_FAILURE);
    }

  rval = EXECUTION_SUCCESS;
  if ((flags & OFLAG) && ((flags & (SFLAG|UFLAG)) == 0))	/* shopt -o */
    rval = list_shopt_o_options (list, flags);
  else if (list && (flags & OFLAG))		/* shopt -so args */
    rval = set_shopt_o_options ((flags & SFLAG) ? FLAG_ON : FLAG_OFF, list, flags & QFLAG);
  else if (flags & OFLAG)	/* shopt -so */
    rval = list_some_o_options ((flags & SFLAG) ? 1 : 0, flags);
  else if (list && (flags & (SFLAG|UFLAG)))	/* shopt -su args */
    rval = toggle_shopts ((flags & SFLAG) ? SETOPT : UNSETOPT, list, flags & QFLAG);
  else if ((flags & (SFLAG|UFLAG)) == 0)	/* shopt [args] */
    rval = list_shopts (list, flags);
  else						/* shopt -su */
    rval = list_some_shopts ((flags & SFLAG) ? SETOPT : UNSETOPT, flags);
  return (rval);
}

/* Reset the options managed by `shopt' to the values they would have at
   shell startup. */
void
reset_shopt_options ()
{
  allow_null_glob_expansion = glob_dot_filenames = 0;
  cdable_vars = mail_warning = 0;
  no_exit_on_failed_exec = print_shift_error = 0;
  check_hashed_filenames = cdspelling = expand_aliases = check_window_size = 0;

  source_uses_path = promptvars = 1;

#if defined (EXTENDED_GLOB)
  extended_glob = 0;
#endif

#if defined (HISTORY)
  literal_history = force_append_history = 0;
  command_oriented_history = 1;
#endif

#if defined (READLINE)
  hist_verify = history_reediting = 0;
  perform_hostname_completion = 1;
#endif

  shopt_login_shell = login_shell;
}

static int
find_shopt (name)
     char *name;
{
  int i;

  for (i = 0; shopt_vars[i].name; i++)
    if (STREQ (name, shopt_vars[i].name))
      return i;
  return -1;
}

static void
shopt_error (s)
     char *s;
{
  builtin_error (_("%s: invalid shell option name"), s);
}

static int
toggle_shopts (mode, list, quiet)
     int mode;
     WORD_LIST *list;
     int quiet;
{
  WORD_LIST *l;
  int ind, rval;

  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
    {
      ind = find_shopt (l->word->word);
      if (ind < 0)
	{
	  shopt_error (l->word->word);
	  rval = EXECUTION_FAILURE;
	}
      else
	{
	  *shopt_vars[ind].value = mode;	/* 1 for set, 0 for unset */
	  if (shopt_vars[ind].set_func)
	    (*shopt_vars[ind].set_func) (mode);
	}
    }
  return (rval);
}

static void
print_shopt (name, val, flags)
     char *name;
     int val, flags;
{
  if (flags & PFLAG)
    printf ("shopt %s %s\n", val ? "-s" : "-u", name);
  else
    printf (OPTFMT, name, val ? on : off);
}

/* List the values of all or any of the `shopt' options.  Returns 0 if
   all were listed or all variables queried were on; 1 otherwise. */
static int
list_shopts (list, flags)
     WORD_LIST *list;
     int flags;
{
  WORD_LIST *l;
  int i, val, rval;

  if (list == 0)
    {
      for (i = 0; shopt_vars[i].name; i++)
	{
	  val = *shopt_vars[i].value;
	  if ((flags & QFLAG) == 0)
	    print_shopt (shopt_vars[i].name, val, flags);
	}
      return (EXECUTION_SUCCESS);
    }

  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
    {
      i = find_shopt (l->word->word);
      if (i < 0)
	{
	  shopt_error (l->word->word);
	  rval = EXECUTION_FAILURE;
	  continue;
	}
      val = *shopt_vars[i].value;
      if (val == 0)
	rval = EXECUTION_FAILURE;
      if ((flags & QFLAG) == 0)
	print_shopt (l->word->word, val, flags);
    }

  return (rval);
}

static int
list_some_shopts (mode, flags)
     int mode, flags;
{
  int val, i;

  for (i = 0; shopt_vars[i].name; i++)
    {
      val = *shopt_vars[i].value;
      if (((flags & QFLAG) == 0) && mode == val)
	print_shopt (shopt_vars[i].name, val, flags);
    }
  return (EXECUTION_SUCCESS);
}

static int
list_shopt_o_options (list, flags)
     WORD_LIST *list;
     int flags;
{
  WORD_LIST *l;
  int val, rval;

  if (list == 0)
    {
      if ((flags & QFLAG) == 0)
	list_minus_o_opts (-1, (flags & PFLAG));
      return (EXECUTION_SUCCESS);
    }

  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
    {
      val = minus_o_option_value (l->word->word);
      if (val == -1)
	{
	  sh_invalidoptname (l->word->word);
	  rval = EXECUTION_FAILURE;
	  continue;
	}
      if (val == 0)
	rval = EXECUTION_FAILURE;
      if ((flags & QFLAG) == 0)
	{
	  if (flags & PFLAG)
	    printf ("set %co %s\n", val ? '-' : '+', l->word->word);
	  else
	    printf (OPTFMT, l->word->word, val ? on : off);
	}
    }
  return (rval);
}

static int
list_some_o_options (mode, flags)
     int mode, flags;
{
  if ((flags & QFLAG) == 0)
    list_minus_o_opts (mode, (flags & PFLAG));
  return (EXECUTION_SUCCESS);
}

static int
set_shopt_o_options (mode, list, quiet)
     int mode;
     WORD_LIST *list;
     int quiet;
{
  WORD_LIST *l;
  int rval;

  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
    {
      if (set_minus_o_option (mode, l->word->word) == EXECUTION_FAILURE)
	rval = EXECUTION_FAILURE;
    }
  set_shellopts ();
  return rval;
}

/* If we set or unset interactive_comments with shopt, make sure the
   change is reflected in $SHELLOPTS. */
static int
set_shellopts_after_change (mode)
     int mode;
{
  set_shellopts ();
  return (0);
}

#if defined (RESTRICTED_SHELL)
/* Don't allow the value of restricted_shell to be modified. */

static int
set_restricted_shell (mode)
     int mode;
{
  static int save_restricted = -1;

  if (save_restricted == -1)
    save_restricted = shell_is_restricted (shell_name);

  restricted_shell = save_restricted;
  return (0);
}
#endif /* RESTRICTED_SHELL */

/* Not static so shell.c can call it to initialize shopt_login_shell */
int
set_login_shell (mode)
     int mode;
{
  shopt_login_shell = login_shell != 0;
  return (0);
}

char **
get_shopt_options ()
{
  char **ret;
  int n, i;

  n = sizeof (shopt_vars) / sizeof (shopt_vars[0]);
  ret = strvec_create (n + 1);
  for (i = 0; shopt_vars[i].name; i++)
    ret[i] = savestring (shopt_vars[i].name);
  ret[i] = (char *)NULL;
  return ret;
}

/*
 * External interface for other parts of the shell.  NAME is a string option;
 * MODE is 0 if we want to unset an option; 1 if we want to set an option.
 * REUSABLE is 1 if we want to print output in a form that may be reused.
 */
int
shopt_setopt (name, mode)
     char *name;
     int mode;
{
  WORD_LIST *wl;
  int r;

  wl = add_string_to_list (name, (WORD_LIST *)NULL);
  r = toggle_shopts (mode, wl, 0);
  dispose_words (wl);
  return r;
}

int
shopt_listopt (name, reusable)
     char *name;
     int reusable;
{
  int i;

  if (name == 0)
    return (list_shopts ((WORD_LIST *)NULL, reusable ? PFLAG : 0));

  i = find_shopt (name);
  if (i < 0)
    {
      shopt_error (name);
      return (EXECUTION_FAILURE);
    }

  print_shopt (name, *shopt_vars[i].value, reusable ? PFLAG : 0);
  return (EXECUTION_SUCCESS);
}
Commit	Line	Data
ccc6cda3 JA	1	This file is shopt.def, from which is created shopt.c.
	2	It implements the Bash `shopt' builtin.
	3
b80f6443	4	Copyright (C) 1994-2003 Free Software Foundation, Inc.
ccc6cda3 JA	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
ccc6cda3 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.
ccc6cda3 JA	21
	22	$PRODUCES shopt.c
	23
	24	$BUILTIN shopt
ccc6cda3 JA	25	$FUNCTION shopt_builtin
	26	$SHORT_DOC shopt [-pqsu] [-o long-option] optname [optname...]
	27	Toggle the values of variables controlling optional behavior.
	28	The -s flag means to enable (set) each OPTNAME; the -u flag
	29	unsets each OPTNAME. The -q flag suppresses output; the exit
	30	status indicates whether each OPTNAME is set or unset. The -o
	31	option restricts the OPTNAMEs to those defined for use with
	32	`set -o'. With no options, or with the -p option, a list of all
	33	settable options is displayed, with an indication of whether or
	34	not each is set.
	35	$END
	36
	37	#include <config.h>
	38
	39	#if defined (HAVE_UNISTD_H)
cce855bc JA	40	# ifdef _MINIX
	41	# include <sys/types.h>
	42	# endif
ccc6cda3 JA	43	# include <unistd.h>
	44	#endif
	45
	46	#include <stdio.h>
	47
b80f6443 JA	48	#include "../bashintl.h"
b80f6443 JA	49
ccc6cda3 JA	50	#include "../shell.h"
	51	#include "../flags.h"
	52	#include "common.h"
	53	#include "bashgetopt.h"
	54
	55	#define UNSETOPT 0
	56	#define SETOPT 1
	57
	58	#define OPTFMT "%-15s\t%s\n"
	59
b80f6443	60	extern int allow_null_glob_expansion, fail_glob_expansion, glob_dot_filenames;
ccc6cda3 JA	61	extern int cdable_vars, mail_warning, source_uses_path;
ccc6cda3 JA	62	extern int no_exit_on_failed_exec, print_shift_error;
7117c2d2	63	extern int check_hashed_filenames, promptvars;
ccc6cda3	64	extern int cdspelling, expand_aliases;
b80f6443	65	extern int extended_quote;
ccc6cda3	66	extern int check_window_size;
cce855bc JA	67	extern int glob_ignore_case;
cce855bc JA	68	extern int hup_on_exit;
bb70624e	69	extern int xpg_echo;
b80f6443	70	extern int gnu_error_format;
cce855bc JA	71
	72	#if defined (EXTENDED_GLOB)
	73	extern int extended_glob;
	74	#endif
ccc6cda3 JA	75
ccc6cda3 JA	76	#if defined (HISTORY)
d166f048	77	extern int literal_history, command_oriented_history;
ccc6cda3 JA	78	extern int force_append_history;
	79	#endif
	80
	81	#if defined (READLINE)
d166f048	82	extern int hist_verify, history_reediting, perform_hostname_completion;
bb70624e	83	extern int no_empty_command_completion;
b80f6443	84	extern int force_fignore;
f73dda09	85	extern int enable_hostname_completion __P((int));
ccc6cda3 JA	86	#endif
ccc6cda3 JA	87
bb70624e JA	88	#if defined (PROGRAMMABLE_COMPLETION)
	89	extern int prog_completion_enabled;
	90	#endif
	91
b72432fd	92	#if defined (RESTRICTED_SHELL)
b72432fd JA	93	extern char *shell_name;
	94	#endif
	95
b80f6443 JA	96	#if defined (DEBUGGER)
	97	extern int debugging_mode;
	98	#endif
	99
7117c2d2 JA	100	static void shopt_error __P((char *));
7117c2d2 JA	101
b80f6443	102	static int set_shellopts_after_change __P((int));
ccc6cda3	103
b72432fd	104	#if defined (RESTRICTED_SHELL)
f73dda09	105	static int set_restricted_shell __P((int));
b72432fd JA	106	#endif
b72432fd JA	107
f73dda09 JA	108	static int shopt_login_shell;
	109
	110	typedef int shopt_set_func_t __P((int));
	111
ccc6cda3 JA	112	static struct {
	113	char *name;
	114	int *value;
f73dda09	115	shopt_set_func_t *set_func;
ccc6cda3	116	} shopt_vars[] = {
f73dda09 JA	117	{ "cdable_vars", &cdable_vars, (shopt_set_func_t *)NULL },
	118	{ "cdspell", &cdspelling, (shopt_set_func_t *)NULL },
	119	{ "checkhash", &check_hashed_filenames, (shopt_set_func_t *)NULL },
	120	{ "checkwinsize", &check_window_size, (shopt_set_func_t *)NULL },
ccc6cda3	121	#if defined (HISTORY)
f73dda09	122	{ "cmdhist", &command_oriented_history, (shopt_set_func_t *)NULL },
ccc6cda3	123	#endif
f73dda09 JA	124	{ "dotglob", &glob_dot_filenames, (shopt_set_func_t *)NULL },
	125	{ "execfail", &no_exit_on_failed_exec, (shopt_set_func_t *)NULL },
	126	{ "expand_aliases", &expand_aliases, (shopt_set_func_t *)NULL },
b80f6443 JA	127	#if defined (DEBUGGER)
	128	{ "extdebug", &debugging_mode, (shopt_set_func_t *)NULL },
	129	#endif
cce855bc	130	#if defined (EXTENDED_GLOB)
f73dda09	131	{ "extglob", &extended_glob, (shopt_set_func_t *)NULL },
cce855bc	132	#endif
b80f6443 JA	133	{ "extquote", &extended_quote, (shopt_set_func_t *)NULL },
b80f6443 JA	134	{ "failglob", &fail_glob_expansion, (shopt_set_func_t *)NULL },
ccc6cda3	135	#if defined (READLINE)
b80f6443 JA	136	{ "force_fignore", &force_fignore, (shopt_set_func_t *)NULL },
b80f6443 JA	137	{ "gnu_errfmt", &gnu_error_format, (shopt_set_func_t *)NULL },
f73dda09	138	{ "histreedit", &history_reediting, (shopt_set_func_t *)NULL },
ccc6cda3 JA	139	#endif
ccc6cda3 JA	140	#if defined (HISTORY)
f73dda09	141	{ "histappend", &force_append_history, (shopt_set_func_t *)NULL },
ccc6cda3 JA	142	#endif
ccc6cda3 JA	143	#if defined (READLINE)
f73dda09 JA	144	{ "histverify", &hist_verify, (shopt_set_func_t *)NULL },
f73dda09 JA	145	{ "hostcomplete", &perform_hostname_completion, enable_hostname_completion },
ccc6cda3	146	#endif
f73dda09	147	{ "huponexit", &hup_on_exit, (shopt_set_func_t *)NULL },
b80f6443	148	{ "interactive_comments", &interactive_comments, set_shellopts_after_change },
ccc6cda3	149	#if defined (HISTORY)
f73dda09	150	{ "lithist", &literal_history, (shopt_set_func_t *)NULL },
ccc6cda3	151	#endif
f73dda09 JA	152	{ "login_shell", &shopt_login_shell, set_login_shell },
f73dda09 JA	153	{ "mailwarn", &mail_warning, (shopt_set_func_t *)NULL },
bb70624e	154	#if defined (READLINE)
f73dda09	155	{ "no_empty_cmd_completion", &no_empty_command_completion, (shopt_set_func_t *)NULL },
bb70624e	156	#endif
f73dda09 JA	157	{ "nocaseglob", &glob_ignore_case, (shopt_set_func_t *)NULL },
f73dda09 JA	158	{ "nullglob", &allow_null_glob_expansion, (shopt_set_func_t *)NULL },
bb70624e	159	#if defined (PROGRAMMABLE_COMPLETION)
f73dda09	160	{ "progcomp", &prog_completion_enabled, (shopt_set_func_t *)NULL },
bb70624e	161	#endif
f73dda09	162	{ "promptvars", &promptvars, (shopt_set_func_t *)NULL },
b72432fd JA	163	#if defined (RESTRICTED_SHELL)
	164	{ "restricted_shell", &restricted_shell, set_restricted_shell },
	165	#endif
f73dda09 JA	166	{ "shift_verbose", &print_shift_error, (shopt_set_func_t *)NULL },
	167	{ "sourcepath", &source_uses_path, (shopt_set_func_t *)NULL },
	168	{ "xpg_echo", &xpg_echo, (shopt_set_func_t *)NULL },
	169	{ (char )0, (int )0, (shopt_set_func_t *)NULL }
ccc6cda3 JA	170	};
	171
	172	static char *on = "on";
	173	static char *off = "off";
	174
f73dda09 JA	175	static int find_shopt __P((char *));
	176	static int toggle_shopts __P((int, WORD_LIST *, int));
	177	static void print_shopt __P((char *, int, int));
	178	static int list_shopts __P((WORD_LIST *, int));
	179	static int list_some_shopts __P((int, int));
	180	static int list_shopt_o_options __P((WORD_LIST *, int));
	181	static int list_some_o_options __P((int, int));
	182	static int set_shopt_o_options __P((int, WORD_LIST *, int));
ccc6cda3 JA	183
	184	#define SFLAG 0x01
	185	#define UFLAG 0x02
	186	#define QFLAG 0x04
	187	#define OFLAG 0x08
	188	#define PFLAG 0x10
	189
	190	int
	191	shopt_builtin (list)
	192	WORD_LIST *list;
	193	{
	194	int opt, flags, rval;
	195
	196	flags = 0;
	197	reset_internal_getopt ();
	198	while ((opt = internal_getopt (list, "psuoq")) != -1)
	199	{
	200	switch (opt)
	201	{
	202	case 's':
	203	flags \|= SFLAG;
	204	break;
	205	case 'u':
	206	flags \|= UFLAG;
	207	break;
	208	case 'q':
	209	flags \|= QFLAG;
	210	break;
	211	case 'o':
	212	flags \|= OFLAG;
	213	break;
	214	case 'p':
	215	flags \|= PFLAG;
	216	break;
	217	default:
	218	builtin_usage ();
	219	return (EX_USAGE);
	220	}
	221	}
	222	list = loptend;
	223
	224	if ((flags & (SFLAG\|UFLAG)) == (SFLAG\|UFLAG))
	225	{
b80f6443	226	builtin_error (_("cannot set and unset shell options simultaneously"));
ccc6cda3 JA	227	return (EXECUTION_FAILURE);
	228	}
	229
	230	rval = EXECUTION_SUCCESS;
	231	if ((flags & OFLAG) && ((flags & (SFLAG\|UFLAG)) == 0)) /* shopt -o */
cce855bc	232	rval = list_shopt_o_options (list, flags);
ccc6cda3 JA	233	else if (list && (flags & OFLAG)) /* shopt -so args */
	234	rval = set_shopt_o_options ((flags & SFLAG) ? FLAG_ON : FLAG_OFF, list, flags & QFLAG);
	235	else if (flags & OFLAG) /* shopt -so */
cce855bc	236	rval = list_some_o_options ((flags & SFLAG) ? 1 : 0, flags);
ccc6cda3 JA	237	else if (list && (flags & (SFLAG\|UFLAG))) /* shopt -su args */
	238	rval = toggle_shopts ((flags & SFLAG) ? SETOPT : UNSETOPT, list, flags & QFLAG);
	239	else if ((flags & (SFLAG\|UFLAG)) == 0) /* shopt [args] */
cce855bc	240	rval = list_shopts (list, flags);
ccc6cda3	241	else /* shopt -su */
cce855bc	242	rval = list_some_shopts ((flags & SFLAG) ? SETOPT : UNSETOPT, flags);
ccc6cda3 JA	243	return (rval);
	244	}
	245
d166f048 JA	246	/* Reset the options managed by `shopt' to the values they would have at
	247	shell startup. */
	248	void
	249	reset_shopt_options ()
	250	{
	251	allow_null_glob_expansion = glob_dot_filenames = 0;
	252	cdable_vars = mail_warning = 0;
	253	no_exit_on_failed_exec = print_shift_error = 0;
	254	check_hashed_filenames = cdspelling = expand_aliases = check_window_size = 0;
	255
	256	source_uses_path = promptvars = 1;
	257
cce855bc JA	258	#if defined (EXTENDED_GLOB)
	259	extended_glob = 0;
	260	#endif
	261
d166f048 JA	262	#if defined (HISTORY)
	263	literal_history = force_append_history = 0;
	264	command_oriented_history = 1;
	265	#endif
	266
	267	#if defined (READLINE)
	268	hist_verify = history_reediting = 0;
	269	perform_hostname_completion = 1;
	270	#endif
f73dda09 JA	271
f73dda09 JA	272	shopt_login_shell = login_shell;
d166f048 JA	273	}
d166f048 JA	274
ccc6cda3 JA	275	static int
	276	find_shopt (name)
	277	char *name;
	278	{
	279	int i;
	280
	281	for (i = 0; shopt_vars[i].name; i++)
	282	if (STREQ (name, shopt_vars[i].name))
	283	return i;
	284	return -1;
	285	}
	286
7117c2d2 JA	287	static void
	288	shopt_error (s)
	289	char *s;
	290	{
b80f6443	291	builtin_error (_("%s: invalid shell option name"), s);
7117c2d2	292	}
ccc6cda3 JA	293
	294	static int
	295	toggle_shopts (mode, list, quiet)
	296	int mode;
	297	WORD_LIST *list;
	298	int quiet;
	299	{
	300	WORD_LIST *l;
	301	int ind, rval;
	302
	303	for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
	304	{
	305	ind = find_shopt (l->word->word);
	306	if (ind < 0)
	307	{
7117c2d2	308	shopt_error (l->word->word);
ccc6cda3 JA	309	rval = EXECUTION_FAILURE;
	310	}
	311	else
	312	{
	313	shopt_vars[ind].value = mode; / 1 for set, 0 for unset */
	314	if (shopt_vars[ind].set_func)
	315	(*shopt_vars[ind].set_func) (mode);
	316	}
	317	}
	318	return (rval);
	319	}
	320
b72432fd	321	static void
cce855bc JA	322	print_shopt (name, val, flags)
	323	char *name;
	324	int val, flags;
	325	{
	326	if (flags & PFLAG)
	327	printf ("shopt %s %s\n", val ? "-s" : "-u", name);
	328	else
	329	printf (OPTFMT, name, val ? on : off);
	330	}
	331
ccc6cda3 JA	332	/* List the values of all or any of the `shopt' options. Returns 0 if
	333	all were listed or all variables queried were on; 1 otherwise. */
	334	static int
cce855bc	335	list_shopts (list, flags)
ccc6cda3	336	WORD_LIST *list;
cce855bc	337	int flags;
ccc6cda3 JA	338	{
	339	WORD_LIST *l;
	340	int i, val, rval;
	341
	342	if (list == 0)
	343	{
	344	for (i = 0; shopt_vars[i].name; i++)
	345	{
	346	val = *shopt_vars[i].value;
cce855bc JA	347	if ((flags & QFLAG) == 0)
cce855bc JA	348	print_shopt (shopt_vars[i].name, val, flags);
ccc6cda3 JA	349	}
	350	return (EXECUTION_SUCCESS);
	351	}
	352
	353	for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
	354	{
	355	i = find_shopt (l->word->word);
	356	if (i < 0)
	357	{
7117c2d2	358	shopt_error (l->word->word);
ccc6cda3 JA	359	rval = EXECUTION_FAILURE;
	360	continue;
	361	}
	362	val = *shopt_vars[i].value;
	363	if (val == 0)
	364	rval = EXECUTION_FAILURE;
cce855bc	365	if ((flags & QFLAG) == 0)
28ef6c31	366	print_shopt (l->word->word, val, flags);
ccc6cda3	367	}
28ef6c31	368
ccc6cda3 JA	369	return (rval);
	370	}
	371
	372	static int
cce855bc JA	373	list_some_shopts (mode, flags)
cce855bc JA	374	int mode, flags;
ccc6cda3 JA	375	{
	376	int val, i;
	377
	378	for (i = 0; shopt_vars[i].name; i++)
	379	{
	380	val = *shopt_vars[i].value;
cce855bc JA	381	if (((flags & QFLAG) == 0) && mode == val)
cce855bc JA	382	print_shopt (shopt_vars[i].name, val, flags);
ccc6cda3 JA	383	}
	384	return (EXECUTION_SUCCESS);
	385	}
	386
	387	static int
cce855bc	388	list_shopt_o_options (list, flags)
ccc6cda3	389	WORD_LIST *list;
cce855bc	390	int flags;
ccc6cda3 JA	391	{
	392	WORD_LIST *l;
	393	int val, rval;
	394
	395	if (list == 0)
	396	{
cce855bc JA	397	if ((flags & QFLAG) == 0)
cce855bc JA	398	list_minus_o_opts (-1, (flags & PFLAG));
ccc6cda3 JA	399	return (EXECUTION_SUCCESS);
	400	}
	401
	402	for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
	403	{
	404	val = minus_o_option_value (l->word->word);
	405	if (val == -1)
	406	{
7117c2d2	407	sh_invalidoptname (l->word->word);
ccc6cda3 JA	408	rval = EXECUTION_FAILURE;
	409	continue;
	410	}
	411	if (val == 0)
	412	rval = EXECUTION_FAILURE;
cce855bc JA	413	if ((flags & QFLAG) == 0)
	414	{
	415	if (flags & PFLAG)
	416	printf ("set %co %s\n", val ? '-' : '+', l->word->word);
	417	else
	418	printf (OPTFMT, l->word->word, val ? on : off);
	419	}
ccc6cda3 JA	420	}
	421	return (rval);
	422	}
	423
	424	static int
cce855bc JA	425	list_some_o_options (mode, flags)
cce855bc JA	426	int mode, flags;
ccc6cda3	427	{
cce855bc JA	428	if ((flags & QFLAG) == 0)
cce855bc JA	429	list_minus_o_opts (mode, (flags & PFLAG));
ccc6cda3 JA	430	return (EXECUTION_SUCCESS);
	431	}
	432
	433	static int
	434	set_shopt_o_options (mode, list, quiet)
	435	int mode;
	436	WORD_LIST *list;
	437	int quiet;
	438	{
	439	WORD_LIST *l;
	440	int rval;
	441
	442	for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
	443	{
	444	if (set_minus_o_option (mode, l->word->word) == EXECUTION_FAILURE)
	445	rval = EXECUTION_FAILURE;
	446	}
	447	set_shellopts ();
	448	return rval;
	449	}
	450
	451	/* If we set or unset interactive_comments with shopt, make sure the
	452	change is reflected in $SHELLOPTS. */
	453	static int
b80f6443	454	set_shellopts_after_change (mode)
ccc6cda3 JA	455	int mode;
	456	{
	457	set_shellopts ();
	458	return (0);
	459	}
b72432fd JA	460
	461	#if defined (RESTRICTED_SHELL)
	462	/* Don't allow the value of restricted_shell to be modified. */
	463
	464	static int
	465	set_restricted_shell (mode)
	466	int mode;
	467	{
	468	static int save_restricted = -1;
	469
	470	if (save_restricted == -1)
	471	save_restricted = shell_is_restricted (shell_name);
	472
	473	restricted_shell = save_restricted;
	474	return (0);
	475	}
	476	#endif /* RESTRICTED_SHELL */
bb70624e	477
f73dda09 JA	478	/* Not static so shell.c can call it to initialize shopt_login_shell */
	479	int
	480	set_login_shell (mode)
	481	int mode;
	482	{
	483	shopt_login_shell = login_shell != 0;
	484	return (0);
	485	}
	486
bb70624e JA	487	char **
	488	get_shopt_options ()
	489	{
	490	char **ret;
	491	int n, i;
	492
	493	n = sizeof (shopt_vars) / sizeof (shopt_vars[0]);
7117c2d2	494	ret = strvec_create (n + 1);
bb70624e JA	495	for (i = 0; shopt_vars[i].name; i++)
	496	ret[i] = savestring (shopt_vars[i].name);
	497	ret[i] = (char *)NULL;
	498	return ret;
	499	}
f73dda09 JA	500
	501	/*
	502	* External interface for other parts of the shell. NAME is a string option;
	503	* MODE is 0 if we want to unset an option; 1 if we want to set an option.
	504	* REUSABLE is 1 if we want to print output in a form that may be reused.
	505	*/
	506	int
	507	shopt_setopt (name, mode)
	508	char *name;
	509	int mode;
	510	{
	511	WORD_LIST *wl;
	512	int r;
	513
	514	wl = add_string_to_list (name, (WORD_LIST *)NULL);
	515	r = toggle_shopts (mode, wl, 0);
	516	dispose_words (wl);
	517	return r;
	518	}
	519
	520	int
	521	shopt_listopt (name, reusable)
	522	char *name;
	523	int reusable;
	524	{
	525	int i;
	526
	527	if (name == 0)
	528	return (list_shopts ((WORD_LIST *)NULL, reusable ? PFLAG : 0));
	529
	530	i = find_shopt (name);
	531	if (i < 0)
	532	{
7117c2d2	533	shopt_error (name);
f73dda09 JA	534	return (EXECUTION_FAILURE);
	535	}
	536
	537	print_shopt (name, *shopt_vars[i].value, reusable ? PFLAG : 0);
	538	return (EXECUTION_SUCCESS);
	539	}