|
From: Enrico B. <enr...@us...> - 2002-03-11 01:47:09
|
Update of /cvsroot/winbash/winbash/builtins
In directory usw-pr-cvs1:/tmp/cvs-serv23905/builtins
Modified Files:
declare.def fc.def getopt.c getopt.h getopts.def kill.def
read.def
Log Message:
Applied GNU bash 1.14.5 diffs
Index: declare.def
===================================================================
RCS file: /cvsroot/winbash/winbash/builtins/declare.def,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- declare.def 10 Mar 2002 21:45:14 -0000 1.3
+++ declare.def 11 Mar 2002 01:47:04 -0000 1.4
@@ -219,13 +219,29 @@
else
{
SHELL_VAR *find_function (), *funvar;
+
funvar = find_function (name);
if (funvar)
{
- char *result = named_function_string
- (name, (COMMAND *)function_cell (funvar), 1);
- printf ("%s\n", result);
+ if (readonly_p (funvar) && (flags_off & att_readonly))
+ {
+ builtin_error ("%s: readonly function", name);
+ any_failed++;
+ NEXT_VARIABLE ();
+ }
+
+ if (flags_on == att_function && flags_off == 0)
+ {
+ char *result = named_function_string
+ (name, (COMMAND *)function_cell (funvar), 1);
+ printf ("%s\n", result);
+ }
+ else
+ {
+ funvar->attributes |= flags_on;
+ funvar->attributes &= ~flags_off;
+ }
}
else
any_failed++;
@@ -241,13 +257,7 @@
if (!var)
var = bind_variable (name, "");
- /* We are not allowed to rebind readonly variables that
- already are readonly unless we are turning off the
- readonly bit. */
- if (flags_off & att_readonly)
- flags_on &= ~att_readonly;
-
- if (value && readonly_p (var) && (!(flags_off & att_readonly)))
+ if (readonly_p (var) && (flags_off & att_readonly))
{
builtin_error ("%s: readonly variable", name);
any_failed++;
Index: fc.def
===================================================================
RCS file: /cvsroot/winbash/winbash/builtins/fc.def,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- fc.def 10 Mar 2002 15:54:11 -0000 1.3
+++ fc.def 11 Mar 2002 01:47:04 -0000 1.4
@@ -299,6 +299,8 @@
{
histend = last_hist;
histbeg = histend - 16;
+ if (histbeg < 0)
+ histbeg = 0;
}
else
{
Index: getopt.c
===================================================================
RCS file: /cvsroot/winbash/winbash/builtins/getopt.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- getopt.c 9 Mar 2002 04:20:36 -0000 1.2
+++ getopt.c 11 Mar 2002 01:47:04 -0000 1.3
@@ -1,9 +1,6 @@
-/* Getopt for GNU.
- NOTE: getopt is now part of the C library, so if you don't know what
- "Keep this file name-space clean" means, talk to ro...@gn...
- before changing it!
+/* getopt for BASH.
- Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
+ Copyright (C) 1993, 1994
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
@@ -18,119 +15,44 @@
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/* NOTE!!! AIX requires this to be the first thing in the file.
- Do not put ANYTHING before it! */
-#if !defined (__GNUC__) && defined (_AIX) && !defined (IBMESA)
- #pragma alloca
-#endif
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef __GNUC__
-#define alloca __builtin_alloca
-#else /* not __GNUC__ */
-#if defined (HAVE_ALLOCA_H) || (defined(sparc) && (defined(sun) || (!defined(USG) && !defined(SVR4) && !defined(__svr4__))))
-#if defined (IBMESA)
-#include <malloc.h>
-#else
-#include <alloca.h>
-#endif /* !IBMESA */
-#else
-#ifndef _AIX
-char *alloca ();
-#endif
-#endif /* alloca.h */
-#endif /* not __GNUC__ */
-
-#if !__STDC__ && !defined(const) && IN_GCC
-#define const
-#endif
+ Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
-#ifdef __NT_VC__
-#include <malloc.h>
-#include "../nt_types.h"
-#endif
+#include <config.h>
-/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>. */
-#ifndef _NO_PROTO
-#define _NO_PROTO
+#if defined (HAVE_UNISTD_H)
+# ifdef _MINIX
+# include <sys/types.h>
+# endif
+# include <unistd.h>
#endif
#include <stdio.h>
-
-/* Comment out all this code if we are using the GNU C Library, and are not
- actually compiling the library itself. This code is part of the GNU C
- Library, but also included in many other GNU distributions. Compiling
- and linking in this code is a waste when using the GNU C library
- (especially if it is a shared library). Rather than having every GNU
- program understand `configure --with-gnu-libc' and omit the object files,
- it is simpler to just do this in the source for each such file. */
-
-#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
-
-
-/* This needs to come after some library #include
- to get __GNU_LIBRARY__ defined. */
-#ifdef __GNU_LIBRARY__
-#undef alloca
-/* Don't include stdlib.h for non-GNU C libraries because some of them
- contain conflicting prototypes for getopt. */
-#include <stdlib.h>
-#else /* Not GNU C library. */
-#define __alloca alloca
-#endif /* GNU C library. */
-
-#if !defined (__STDC__) && !defined (const)
-# define const
-#endif
-
-/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
- long-named option. Because this is not POSIX.2 compliant, it is
- being phased out. */
-/* #define GETOPT_COMPAT */
-
-/* This version of `getopt' appears to the caller like standard Unix `getopt'
- but it behaves differently for the user, since it allows the user
- to intersperse the options with the other arguments.
-
- As `getopt' works, it permutes the elements of ARGV so that,
- when it is done, all the options precede everything else. Thus
- all application programs are extended to handle flexible argument order.
-
- Setting the environment variable POSIXLY_CORRECT disables permutation.
- Then the behavior is completely standard.
-
- GNU application programs can use a third alternative mode in which
- they can distinguish the relative order of options and other arguments. */
-
+#include "memalloc.h"
+#include "../shell.h"
#include "getopt.h"
-/* For communication from `getopt' to the caller.
- When `getopt' finds an option that takes an argument,
- the argument value is returned here.
- Also, when `ordering' is RETURN_IN_ORDER,
- each non-option ARGV-element is returned here. */
-
-char *optarg = 0;
+/* For communication from `sh_getopt' to the caller.
+ When `sh_getopt' finds an option that takes an argument,
+ the argument value is returned here. */
+char *sh_optarg = 0;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
- and for communication between successive calls to `getopt'.
+ and for communication between successive calls to `sh_getopt'.
- On entry to `getopt', zero means this is the first call; initialize.
+ On entry to `sh_getopt', zero means this is the first call; initialize.
- When `getopt' returns EOF, this is the index of the first of the
+ When `sh_getopt' returns EOF, this is the index of the first of the
non-option elements that the caller should itself scan.
- Otherwise, `optind' communicates from one call to the next
+ Otherwise, `sh_optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
/* XXX 1003.2 says this must be 1 before any call. */
-int optind = 0;
+int sh_optind = 0;
+
+/* Index of the current argument. */
+static int sh_curopt;
/* The next char to be scanned in the option-element
in which the last option character we returned was found.
@@ -140,217 +62,65 @@
by advancing to the next ARGV-element. */
static char *nextchar;
+static int sh_charindex;
/* Callers store zero here to inhibit the error message
for unrecognized options. */
-int opterr = 1;
+int sh_opterr = 1;
/* Set to an option character which was unrecognized.
This must be initialized on some systems to avoid linking in the
system's own getopt implementation. */
-int optopt = '?';
-
-/* Describe how to deal with options that follow non-option ARGV-elements.
-
- If the caller did not specify anything,
- the default is REQUIRE_ORDER if the environment variable
- POSIXLY_CORRECT is defined, PERMUTE otherwise.
-
- REQUIRE_ORDER means don't recognize them as options;
- stop option processing when the first non-option is seen.
- This is what Unix does.
- This mode of operation is selected by either setting the environment
- variable POSIXLY_CORRECT, or using `+' as the first character
- of the list of option characters.
-
- PERMUTE is the default. We permute the contents of ARGV as we scan,
- so that eventually all the non-options are at the end. This allows options
- to be given in any order, even with programs that were not written to
- expect this.
-
- RETURN_IN_ORDER is an option available to programs that were written
- to expect options and other ARGV-elements in any order and that care about
- the ordering of the two. We describe each non-option ARGV-element
- as if it were the argument of an option with character code 1.
- Using `-' as the first character of the list of option characters
- selects this mode of operation.
-
- The special argument `--' forces an end of option-scanning regardless
- of the value of `ordering'. In the case of RETURN_IN_ORDER, only
- `--' can cause `getopt' to return EOF with `optind' != ARGC. */
-
-static enum
-{
- REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
-} ordering, default_ordering = PERMUTE;
-
-#ifdef __GNU_LIBRARY__
-/* We want to avoid inclusion of string.h with non-GNU libraries
- because there are many ways it can cause trouble.
- On some systems, it contains special magic macros that don't work
- in GCC. */
-#include <string.h>
-#define my_index strchr
-#define my_bcopy(src, dst, n) memcpy ((dst), (src), (n))
-#else
-
-/* Avoid depending on library functions or files
- whose names are inconsistent. */
-
-char *getenv ();
-
-static char *
-my_index (str, chr)
- const char *str;
- int chr;
-{
- while (*str)
- {
- if (*str == chr)
- return (char *) str;
- str++;
- }
- return 0;
-}
-
-static void
-my_bcopy (from, to, size)
- const char *from;
- char *to;
- int size;
-{
- int i;
- for (i = 0; i < size; i++)
- to[i] = from[i];
-}
-#endif /* GNU C library. */
-
-/* Handle permutation of arguments. */
-
-/* Describe the part of ARGV that contains non-options that have
- been skipped. `first_nonopt' is the index in ARGV of the first of them;
- `last_nonopt' is the index after the last of them. */
-
-static int first_nonopt;
-static int last_nonopt;
-
-/* Exchange two adjacent subsequences of ARGV.
- One subsequence is elements [first_nonopt,last_nonopt)
- which contains all the non-options that have been skipped so far.
- The other is elements [last_nonopt,optind), which contains all
- the options processed since those non-options were skipped.
-
- `first_nonopt' and `last_nonopt' are relocated so that they describe
- the new indices of the non-options in ARGV after they are moved. */
-
-static void
-exchange (argv)
- char **argv;
-{
- int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
- char **temp = (char **) __alloca (nonopts_size);
-
- /* Interchange the two blocks of data in ARGV. */
-
- my_bcopy ((char *) &argv[first_nonopt], (char *) temp, nonopts_size);
- my_bcopy ((char *) &argv[last_nonopt], (char *) &argv[first_nonopt],
- (optind - last_nonopt) * sizeof (char *));
- my_bcopy ((char *) temp,
- (char *) &argv[first_nonopt + optind - last_nonopt],
- nonopts_size);
+int sh_optopt = '?';
- /* Update records for the slots the non-options now occupy. */
+/* Set to 1 when we see an illegal option; public so getopts can reset it. */
+int sh_badopt = 0;
- first_nonopt += (optind - last_nonopt);
- last_nonopt = optind;
-}
-
/* Scan elements of ARGV (whose length is ARGC) for option characters
given in OPTSTRING.
If an element of ARGV starts with '-', and is not exactly "-" or "--",
then it is an option element. The characters of this element
- (aside from the initial '-') are option characters. If `getopt'
+ (aside from the initial '-') are option characters. If `sh_getopt'
is called repeatedly, it returns successively each of the option characters
from each of the option elements.
- If `getopt' finds another option character, it returns that character,
- updating `optind' and `nextchar' so that the next call to `getopt' can
+ If `sh_getopt' finds another option character, it returns that character,
+ updating `sh_optind' and `nextchar' so that the next call to `sh_getopt' can
resume the scan with the following option character or ARGV-element.
- If there are no more option characters, `getopt' returns `EOF'.
- Then `optind' is the index in ARGV of the first ARGV-element
- that is not an option. (The ARGV-elements have been permuted
- so that those that are not options now come last.)
+ If there are no more option characters, `sh_getopt' returns `EOF'.
+ Then `sh_optind' is the index in ARGV of the first ARGV-element
+ that is not an option.
OPTSTRING is a string containing the legitimate option characters.
If an option character is seen that is not listed in OPTSTRING,
- return '?' after printing an error message. If you set `opterr' to
+ return '?' after printing an error message. If you set `sh_opterr' to
zero, the error message is suppressed but we still return '?'.
If a char in OPTSTRING is followed by a colon, that means it wants an arg,
so the following text in the same ARGV-element, or the text of the following
- ARGV-element, is returned in `optarg'. Two colons mean an option that
- wants an optional arg; if there is text in the current ARGV-element,
- it is returned in `optarg', otherwise `optarg' is set to zero.
-
- If OPTSTRING starts with `-' or `+', it requests different methods of
- handling the non-option ARGV-elements.
- See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
-
- Long-named options begin with `--' instead of `-'.
- Their names may be abbreviated as long as the abbreviation is unique
- or is an exact match for some defined option. If they have an
- argument, it follows the option name in the same ARGV-element, separated
- from the option name by a `=', or else the in next ARGV-element.
- When `getopt' finds a long-named option, it returns 0 if that option's
- `flag' field is nonzero, the value of the option's `val' field
- if the `flag' field is zero.
-
- The elements of ARGV aren't really const, because we permute them.
- But we pretend they're const in the prototype to be compatible
- with other systems.
-
- LONGOPTS is a vector of `struct option' terminated by an
- element containing a name which is zero.
-
- LONGIND returns the index in LONGOPT of the long-named option found.
- It is only valid when a long-named option has been found by the most
- recent call.
+ ARGV-element, is returned in `sh_optarg'. */
- If LONG_ONLY is nonzero, '-' as well as '--' can introduce
- long-named options. */
+/* 1003.2 specifies the format of this message. */
+#define BADOPT(c) fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c)
+#define NEEDARG(c) fprintf (stderr, "%s: option requires an argument -- %c\n", argv[0], c)
-/* Call this function with an argument of 1 to set the default option
- ordering to that required by Posix. The normal default is PERMUTE. */
-void
-getopt_set_posix_option_order (on_or_off)
- int on_or_off;
-{
- if (on_or_off == 1)
- default_ordering = REQUIRE_ORDER;
- else
- default_ordering = PERMUTE;
-}
-
int
-_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+sh_getopt (argc, argv, optstring)
int argc;
char *const *argv;
const char *optstring;
- const struct option *longopts;
- int *longind;
- int long_only;
{
- int option_index;
+ char c, *temp;
- optarg = 0;
+ sh_optarg = 0;
- if (optind > argc || optind < 0)
+ if (sh_optind >= argc || sh_optind < 0) /* XXX was sh_optind > argc */
{
- optind = argc;
+ sh_optind = argc;
return (EOF);
}
@@ -359,374 +129,126 @@
is the program name); the sequence of previously skipped
non-option ARGV-elements is empty. */
- if (optind == 0)
+ if (sh_optind == 0)
{
- first_nonopt = last_nonopt = optind = 1;
-
- nextchar = NULL;
-
- /* Determine how to handle the ordering of options and nonoptions. */
-
- if (optstring[0] == '-')
- {
- ordering = RETURN_IN_ORDER;
- ++optstring;
- }
- else if (optstring[0] == '+')
- {
- ordering = REQUIRE_ORDER;
- ++optstring;
- }
- else if (getenv ("POSIXLY_CORRECT") != NULL)
- ordering = REQUIRE_ORDER;
- else
- ordering = default_ordering;
+ sh_optind = 1;
+ nextchar = (char *)NULL;
}
- if (nextchar == NULL || *nextchar == '\0')
+ /* Do the increment of `sh_optind' we deferred because the last option
+ was illegal. */
+ if (sh_badopt && (nextchar == 0 || *nextchar == '\0'))
{
- if (ordering == PERMUTE)
- {
- /* If we have just processed some options following some non-options,
- exchange them so that the options come first. */
-
- if (first_nonopt != last_nonopt && last_nonopt != optind)
- exchange ((char **) argv);
- else if (last_nonopt != optind)
- first_nonopt = optind;
+ sh_badopt = 0;
+ sh_optind++;
+ nextchar = (char *)NULL;
+ }
- /* Now skip any additional non-options
- and extend the range of non-options previously skipped. */
+ if (nextchar == 0 || *nextchar == '\0')
+ {
+ /* If we have done all the ARGV-elements, stop the scan. */
+ if (sh_optind >= argc)
+ return EOF;
- while (optind < argc
- && (argv[optind][0] != '-' || argv[optind][1] == '\0')
-#ifdef GETOPT_COMPAT
- && (longopts == NULL
- || argv[optind][0] != '+' || argv[optind][1] == '\0')
-#endif /* GETOPT_COMPAT */
- )
- optind++;
- last_nonopt = optind;
- }
+ temp = argv[sh_optind];
/* Special ARGV-element `--' means premature end of options.
- Skip it like a null option,
- then exchange with previous non-options as if it were an option,
- then skip everything else like a non-option. */
-
- if (optind != argc && !strcmp (argv[optind], "--"))
- {
- optind++;
-
- if (first_nonopt != last_nonopt && last_nonopt != optind)
- exchange ((char **) argv);
- else if (first_nonopt == last_nonopt)
- first_nonopt = optind;
- last_nonopt = argc;
-
- optind = argc;
- }
-
- /* If we have done all the ARGV-elements, stop the scan
- and back over any non-options that we skipped and permuted. */
-
- if (optind == argc)
+ Skip it like a null option, and return EOF. */
+ if (temp[0] == '-' && temp[1] == '-' && temp[2] == '\0')
{
- /* Set the next-arg-index to point at the non-options
- that we previously skipped, so the caller will digest them. */
- if (first_nonopt != last_nonopt)
- optind = first_nonopt;
+ sh_optind++;
return EOF;
}
- /* If we have come to a non-option and did not permute it,
- either stop the scan or describe it to the caller and pass it by. */
-
- if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
-#ifdef GETOPT_COMPAT
- && (longopts == NULL
- || argv[optind][0] != '+' || argv[optind][1] == '\0')
-#endif /* GETOPT_COMPAT */
- )
- {
- if (ordering == REQUIRE_ORDER)
- return EOF;
- optarg = argv[optind++];
- return 1;
- }
+ /* If we have come to a non-option, either stop the scan or describe
+ it to the caller and pass it by. This makes the pseudo-option
+ `-' mean the end of options, but does not skip over it. */
+ if (temp[0] != '-' || temp[1] == '\0')
+ return EOF;
/* We have found another option-ARGV-element.
Start decoding its characters. */
-
- nextchar = (argv[optind] + 1
- + (longopts != NULL && argv[optind][1] == '-'));
+ nextchar = argv[sh_curopt = sh_optind] + 1;
+ sh_charindex = 1;
}
- if (longopts != NULL
- && ((argv[optind][0] == '-'
- && (argv[optind][1] == '-' || long_only))
-#ifdef GETOPT_COMPAT
- || argv[optind][0] == '+'
-#endif /* GETOPT_COMPAT */
- ))
+ /* Look at and handle the next option-character. */
+
+ c = *nextchar++; sh_charindex++;
+ temp = strchr (optstring, c);
+
+ sh_optopt = c;
+
+ /* If the option is illegal, return an error, but defer updating sh_optind
+ until the next call so $OPTIND is correct. */
+ if (sh_badopt = (temp == NULL || c == ':'))
{
- const struct option *p;
- char *s = nextchar;
- int exact = 0;
- int ambig = 0;
- const struct option *pfound = NULL;
- int indfound;
+ if (sh_opterr)
+ BADOPT (c);
- while (*s && *s != '=')
- s++;
+ return '?';
+ }
- /* Test all options for either exact match or abbreviated matches. */
- for (p = longopts, option_index = 0; p->name;
- p++, option_index++)
- if (!strncmp (p->name, nextchar, s - nextchar))
- {
- if (s - nextchar == strlen (p->name))
- {
- /* Exact match found. */
- pfound = p;
- indfound = option_index;
- exact = 1;
- break;
- }
- else if (pfound == NULL)
- {
- /* First nonexact match found. */
- pfound = p;
- indfound = option_index;
- }
- else
- /* Second nonexact match found. */
- ambig = 1;
- }
+ /* Increment `sh_optind' when we start to process its last character. */
+ if (nextchar == 0 || *nextchar == '\0')
+ {
+ sh_optind++;
+ nextchar = (char *)NULL;
+ }
- if (ambig && !exact)
+ if (temp[1] == ':')
+ {
+ if (nextchar && *nextchar)
{
- if (opterr)
- {
- fprintf (stderr, "%s: option `%s' is ambiguous\n",
- argv[0], argv[optind]);
- fflush (stderr);
- }
-
- nextchar = "";
- optind++;
- return '?';
+ /* This is an option that requires an argument. */
+ sh_optarg = nextchar;
+ /* If we end this ARGV-element by taking the rest as an arg,
+ we must advance to the next element now. */
+ sh_optind++;
}
-
- if (pfound != NULL)
+ else if (sh_optind == argc)
{
- option_index = indfound;
- optind++;
- if (*s)
- {
- /* Don't test has_arg with >, because some C compilers don't
- allow it to be used on enums. */
- if (pfound->has_arg)
- optarg = s + 1;
- else
- {
- if (opterr)
- {
- if (argv[optind - 1][1] == '-')
- {
- /* --option */
- fprintf (stderr,
- "%s: option `--%s' doesn't allow an argument\n",
- argv[0], pfound->name);
- fflush (stderr);
- }
- else
- {
- /* +option or -option */
- fprintf (stderr,
- "%s: option `%c%s' doesn't allow an argument\n",
- argv[0], argv[optind - 1][0], pfound->name);
- fflush (stderr);
- }
- }
+ if (sh_opterr)
+ NEEDARG (c);
- nextchar = "";
- return '?';
- }
- }
- else if (pfound->has_arg == 1)
- {
- if (optind < argc)
- optarg = argv[optind++];
- else
- {
- if (opterr)
- {
- fprintf (stderr, "%s: option `%s' requires an argument\n",
- argv[0], argv[optind - 1]);
- fflush (stderr);
- }
- nextchar = "";
- return optstring[0] == ':' ? ':' : '?';
- }
- }
- nextchar = "";
- if (longind != NULL)
- *longind = option_index;
- if (pfound->flag)
- {
- *(pfound->flag) = pfound->val;
- return 0;
- }
- return pfound->val;
- }
- /* Can't find it as a long option. If this is not getopt_long_only,
- or the option starts with '--' or is not a valid short
- option, then it's an error.
- Otherwise interpret it as a short option. */
- if (!long_only || argv[optind][1] == '-'
-#ifdef GETOPT_COMPAT
- || argv[optind][0] == '+'
-#endif /* GETOPT_COMPAT */
- || my_index (optstring, *nextchar) == NULL)
- {
- if (opterr)
- {
- if (argv[optind][1] == '-')
- {
- /* --option */
- fprintf (stderr, "%s: unrecognized option `--%s'\n",
- argv[0], nextchar);
- fflush (stderr);
- }
- else
- {
- /* +option or -option */
- fprintf (stderr, "%s: unrecognized option `%c%s'\n",
- argv[0], argv[optind][0], nextchar);
- fflush (stderr);
- }
- }
- nextchar = (char *) "";
- optind++;
- return '?';
+ sh_optopt = c;
+ sh_optarg = ""; /* Needed by getopts. */
+ c = (optstring[0] == ':') ? ':' : '?';
}
+ else
+ /* We already incremented `sh_optind' once;
+ increment it again when taking next ARGV-elt as argument. */
+ sh_optarg = argv[sh_optind++];
+ nextchar = (char *)NULL;
}
-
- /* Look at and handle the next option-character. */
-
- {
- char c = *nextchar++;
- char *temp = my_index (optstring, c);
-
- /* Increment `optind' when we start to process its last character. */
- if (nextchar == NULL || *nextchar == '\0')
- {
- ++optind;
- nextchar = (char *)NULL;
- }
-
- optopt = c;
-
- if (temp == NULL || c == ':')
- {
- if (opterr)
- {
-#if 0
- if (c < 040 || c >= 0177)
- {
- fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
- argv[0], c);
- fflush (stderr);
- }
- else
- {
- fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
- fflush (stderr);
- }
-#else
- /* 1003.2 specifies the format of this message. */
- fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
- fflush (stderr);
-#endif
- }
- optopt = c;
- return '?';
- }
- if (temp[1] == ':')
- {
- if (temp[2] == ':')
- {
- /* This is an option that accepts an argument optionally. */
- if (nextchar && *nextchar != '\0')
- {
- optarg = nextchar;
- optind++;
- }
- else
- optarg = 0;
- nextchar = (char *)NULL;
- }
- else
- {
- /* This is an option that requires an argument. */
- if (nextchar && *nextchar != '\0')
- {
- optarg = nextchar;
- /* If we end this ARGV-element by taking the rest as an arg,
- we must advance to the next element now. */
- optind++;
- }
- else if (optind == argc)
- {
- if (opterr)
- {
-#if 0
- fprintf (stderr, "%s: option `-%c' requires an argument\n",
- argv[0], c);
- fflush (stderr);
-#else
- /* 1003.2 specifies the format of this message. */
- fprintf (stderr, "%s: option requires an argument -- %c\n",
- argv[0], c);
- fflush (stderr);
-#endif
- }
- optopt = c;
- if (optstring[0] == ':')
- c = ':';
- else
- c = '?';
- }
- else
- /* We already incremented `optind' once;
- increment it again when taking next ARGV-elt as argument. */
- optarg = argv[optind++];
- nextchar = NULL;
- }
- }
- return c;
- }
+ return c;
}
-int
-getopt (argc, argv, optstring)
- int argc;
- char *const *argv;
- const char *optstring;
+void
+sh_getopt_restore_state (argv)
+ char **argv;
{
- return _getopt_internal (argc, argv, optstring,
- (const struct option *) 0,
- (int *) 0,
- 0);
+ if (nextchar)
+ nextchar = argv[sh_curopt] + sh_charindex;
}
-#endif /* _LIBC or not __GNU_LIBRARY__. */
-
+#if 0
+void
+sh_getopt_debug_restore_state (argv)
+ char **argv;
+{
+ if (nextchar && nextchar != argv[sh_curopt] + sh_charindex)
+ {
+ itrace("sh_getopt_debug_restore_state: resetting nextchar");
+ nextchar = argv[sh_curopt] + sh_charindex;
+ }
+}
+#endif
+
#ifdef TEST
/* Compile with -DTEST to make an executable for use in testing
- the above definition of `getopt'. */
+ the above definition of `sh_getopt'. */
int
main (argc, argv)
@@ -734,13 +256,13 @@
char **argv;
{
int c;
- int digit_optind = 0;
+ int digit_sh_optind = 0;
while (1)
{
- int this_option_optind = optind ? optind : 1;
+ int this_option_sh_optind = sh_optind ? sh_optind : 1;
- c = getopt (argc, argv, "abc:d:0123456789");
+ c = sh_getopt (argc, argv, "abc:d:0123456789");
if (c == EOF)
break;
@@ -756,9 +278,9 @@
case '7':
case '8':
case '9':
- if (digit_optind != 0 && digit_optind != this_option_optind)
+ if (digit_sh_optind != 0 && digit_sh_optind != this_option_sh_optind)
printf ("digits occur in two different argv-elements.\n");
- digit_optind = this_option_optind;
+ digit_sh_optind = this_option_sh_optind;
printf ("option %c\n", c);
break;
@@ -771,22 +293,22 @@
break;
case 'c':
- printf ("option c with value `%s'\n", optarg);
+ printf ("option c with value `%s'\n", sh_optarg);
break;
case '?':
break;
default:
- printf ("?? getopt returned character code 0%o ??\n", c);
+ printf ("?? sh_getopt returned character code 0%o ??\n", c);
}
}
- if (optind < argc)
+ if (sh_optind < argc)
{
printf ("non-option ARGV-elements: ");
- while (optind < argc)
- printf ("%s ", argv[optind++]);
+ while (sh_optind < argc)
+ printf ("%s ", argv[sh_optind++]);
printf ("\n");
}
Index: getopt.h
===================================================================
RCS file: /cvsroot/winbash/winbash/builtins/getopt.h,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- getopt.h 9 Mar 2002 04:20:36 -0000 1.2
+++ getopt.h 11 Mar 2002 01:47:04 -0000 1.3
@@ -15,20 +15,18 @@
along with this program; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+/* XXX THIS HAS BEEN MODIFIED FOR INCORPORATION INTO BASH XXX */
+
#ifndef _GETOPT_H
#define _GETOPT_H 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* For communication from `getopt' to the caller.
When `getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
-extern char *optarg;
+extern char *sh_optarg;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
@@ -39,19 +37,22 @@
When `getopt' returns EOF, this is the index of the first of the
non-option elements that the caller should itself scan.
- Otherwise, `optind' communicates from one call to the next
+ Otherwise, `sh_optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
-extern int optind;
+extern int sh_optind;
/* Callers store zero here to inhibit the error message `getopt' prints
for unrecognized options. */
-extern int opterr;
+extern int sh_opterr;
/* Set to an option character which was unrecognized. */
-extern int optopt;
+extern int sh_optopt;
+
+extern int sh_getopt ();
+extern void sh_getopt_restore_state ();
/* Describe the long-named options requested by the application.
The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
Index: getopts.def
===================================================================
RCS file: /cvsroot/winbash/winbash/builtins/getopts.def,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- getopts.def 10 Mar 2002 21:45:14 -0000 1.3
+++ getopts.def 11 Mar 2002 01:47:04 -0000 1.4
@@ -91,7 +91,7 @@
getopts_reset (newind)
int newind;
{
- optind = newind;
+ sh_optind = newind;
}
/* Error handling is now performed as specified by Posix.2, draft 11
@@ -149,16 +149,16 @@
if (special_error)
{
- old_opterr = opterr;
+ old_opterr = sh_opterr;
optstr++;
- opterr = 0; /* suppress diagnostic messages */
+ sh_opterr = 0; /* suppress diagnostic messages */
}
if (argc > 1)
{
t = argv[0];
argv[0] = dollar_vars[0];
- ret = getopt (argc, argv, optstr);
+ ret = sh_getopt (argc, argv, optstr);
argv[0] = t;
}
else if (rest_of_args == (WORD_LIST *)NULL)
@@ -166,7 +166,7 @@
register int i;
for (i = 0; dollar_vars[i]; i++);
- ret = getopt (i, dollar_vars, optstr);
+ ret = sh_getopt (i, dollar_vars, optstr);
}
else
{
@@ -182,24 +182,24 @@
for (words = rest_of_args; words; words = words->next, i++)
v[i] = words->word->word;
v[i] = (char *)NULL;
- ret = getopt (i, v, optstr);
+ ret = sh_getopt (i, v, optstr);
free (v);
}
if (special_error)
- opterr = old_opterr;
+ sh_opterr = old_opterr;
/* Set the OPTIND variable in any case, to handle "--" skipping. */
- if (optind < 10)
+ if (sh_optind < 10)
{
- numval[14] = optind + '0';
+ numval[14] = sh_optind + '0';
numval[15] = '\0';
i = 14;
}
else
{
numval[i = 15] = '\0';
- n = optind;
+ n = sh_optind;
do
{
numval[--i] = (n % 10) + '0';
@@ -210,14 +210,14 @@
/* If an error occurred, decide which one it is and set the return
code appropriately. In all cases, the option character in error
- is in OPTOPT. If an illegal option was encountered, OPTARG is
+ is in SH_OPTOPT. If an illegal option was encountered, OPTARG is
NULL. If a required option argument was missing, OPTARG points
to a NULL string (that is, optarg[0] == 0). */
if (ret == '?')
{
- if (optarg == NULL)
+ if (sh_optarg == NULL)
ret = G_ILLEGAL_OPT;
- else if (optarg[0] == '\0')
+ else if (sh_optarg[0] == '\0')
ret = G_ARG_MISSING;
}
@@ -236,7 +236,7 @@
if (special_error)
{
- strval[0] = (char) optopt;
+ strval[0] = (char) sh_optopt;
strval[1] = '\0';
bind_variable ("OPTARG", strval);
}
@@ -254,7 +254,7 @@
strval[1] = '\0';
bind_variable (name, strval);
- strval[0] = (char) optopt;
+ strval[0] = (char) sh_optopt;
strval[1] = '\0';
bind_variable ("OPTARG", strval);
}
@@ -268,7 +268,7 @@
return (EXECUTION_SUCCESS);
}
- bind_variable ("OPTARG", optarg);
+ bind_variable ("OPTARG", sh_optarg);
strval[0] = (char) ret;
strval[1] = '\0';
Index: kill.def
===================================================================
RCS file: /cvsroot/winbash/winbash/builtins/kill.def,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- kill.def 9 Mar 2002 04:20:36 -0000 1.2
+++ kill.def 11 Mar 2002 01:47:04 -0000 1.3
@@ -39,6 +39,7 @@
extern int errno;
#endif /* !errno */
+#include "../bashtypes.h"
#include "../shell.h"
#include "../trap.h"
#include "../jobs.h"
Index: read.def
===================================================================
RCS file: /cvsroot/winbash/winbash/builtins/read.def,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- read.def 9 Mar 2002 16:05:42 -0000 1.3
+++ read.def 11 Mar 2002 01:47:04 -0000 1.4
@@ -262,6 +262,13 @@
free (orig_input_string);
return (EXECUTION_FAILURE);
}
+
+ /* This has to be done this way rather than using string_list
+ and list_string because Posix.2 says that the last variable gets the
+ remaining words and their intervening separators. */
+ input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars,
+ saw_escape);
+
if (saw_escape)
{
t = dequote_string (input_string);
|
