Imported from ../bash-1.14.7.tar.gz.

.distribution

@@ -0,0 +1 @@
+1.14

.patchlevel

@@ -0,0 +1 @@
+7

COPYING

@@ -0,0 +1,257 @@
+
+		    GNU GENERAL PUBLIC LICENSE
+		     Version 1, February 1989
+
+ Copyright (C) 1989 Free Software Foundation, Inc.
+		    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+The Free Software Foundation has exempted Bash from the requirement of
+Paragraph 2c of the General Public License.  This is to say, there is
+no requirement for Bash to print a notice when it is started
+interactively in the usual way.  We made this exception because users
+and standards expect shells not to print such messages.  This
+exception applies to any program that serves as a shell and that is
+based primarily on Bash as opposed to other GNU software.
+
+			    Preamble
+
+  The license agreements of most software companies try to keep users
+at the mercy of those companies.  By contrast, our General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  The
+General Public License applies to the Free Software Foundation's
+software and to any other program whose authors commit to using it.
+You can use it for your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Specifically, the General Public License is designed to make
+sure that you have the freedom to give away or sell copies of free
+software, that you receive source code or can get it if you want it,
+that you can change the software or use pieces of it in new free
+programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of a such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must tell them their rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any program or other work which
+contains a notice placed by the copyright holder saying it may be
+distributed under the terms of this General Public License.  The
+"Program", below, refers to any such program or work, and a "work based
+on the Program" means either the Program or any work containing the
+Program or a portion of it, either verbatim or with modifications.  Each
+licensee is addressed as "you".
+
+  1. You may copy and distribute verbatim copies of the Program's source
+code as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and
+disclaimer of warranty; keep intact all the notices that refer to this
+General Public License and to the absence of any warranty; and give any
+other recipients of the Program a copy of this General Public License
+along with the Program.  You may charge a fee for the physical act of
+transferring a copy.
+
+  2. You may modify your copy or copies of the Program or any portion of
+it, and copy and distribute such modifications under the terms of Paragraph
+1 above, provided that you also do the following:
+
+    a) cause the modified files to carry prominent notices stating that
+    you changed the files and the date of any change; and
+
+    b) cause the whole of any work that you distribute or publish, that
+    in whole or in part contains the Program or any part thereof, either
+    with or without modifications, to be licensed at no charge to all
+    third parties under the terms of this General Public License (except
+    that you may choose to grant warranty protection to some or all
+    third parties, at your option).
+
+    c) If the modified program normally reads commands interactively when
+    run, you must cause it, when started running for such interactive use
+    in the simplest and most usual way, to print or display an
+    announcement including an appropriate copyright notice and a notice
+    that there is no warranty (or else, saying that you provide a
+    warranty) and that users may redistribute the program under these
+    conditions, and telling the user how to view a copy of this General
+    Public License.
+
+    d) You may charge a fee for the physical act of transferring a
+    copy, and you may at your option offer warranty protection in
+    exchange for a fee.
+
+Mere aggregation of another independent work with the Program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other work under the scope of these terms.
+
+  3. You may copy and distribute the Program (or a portion or derivative of
+it, under Paragraph 2) in object code or executable form under the terms of
+Paragraphs 1 and 2 above provided that you also do one of the following:
+
+    a) accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    b) accompany it with a written offer, valid for at least three
+    years, to give any third party free (except for a nominal charge
+    for the cost of distribution) a complete machine-readable copy of the
+    corresponding source code, to be distributed under the terms of
+    Paragraphs 1 and 2 above; or,
+
+    c) accompany it with the information you received as to where the
+    corresponding source code may be obtained.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form alone.)
+
+Source code for a work means the preferred form of the work for making
+modifications to it.  For an executable file, complete source code means
+all the source code for all modules it contains; but, as a special
+exception, it need not include source code for modules which are standard
+libraries that accompany the operating system on which the executable
+file runs, or for standard header files or definitions files that
+accompany that operating system.
+
+  4. You may not copy, modify, sublicense, distribute or transfer the
+Program except as expressly provided under this General Public License.
+Any attempt otherwise to copy, modify, sublicense, distribute or transfer
+the Program is void, and will automatically terminate your rights to use
+the Program under this License.  However, parties who have received
+copies, or rights to use copies, from you under this General Public
+License will not have their licenses terminated so long as such parties
+remain in full compliance.
+
+  5. By copying, distributing or modifying the Program (or any work based
+on the Program) you indicate your acceptance of this license to do so,
+and all its terms and conditions.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the original
+licensor to copy, distribute or modify the Program subject to these
+terms and conditions.  You may not impose any further restrictions on the
+recipients' exercise of the rights granted herein.
+
+  7. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of the license which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+the license, you may choose any version ever published by the Free Software
+Foundation.
+
+  8. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  9. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to humanity, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+  To do so, attach the following notices to the program.  It is safest to
+attach them to the start of each source file to most effectively convey
+the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy	<name of author>
+
+    This program 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 1, or (at your option)
+    any later version.
+
+    This program 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 this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) 19xx name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the
+appropriate parts of the General Public License.  Of course, the
+commands you use may be called something other than `show w' and `show
+c'; they could even be mouse-clicks or menu items--whatever suits your
+program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  program `Gnomovision' (a program to direct compilers to make passes
+  at assemblers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+That's all there is to it!

CWRU/PLATFORMS

@@ -0,0 +1,18 @@
+The version of bash in this directory has been compiled on the
+following systems:
+
+Sun 690			SunOS 4.1.2
+Sparcstation		SunOS 5.3
+Sparcstation		NetBSD 0.9a
+386			BSDI BSD/386 1.0, 1.1
+NeXTstation		NeXT OS 2.1
+IBM RT			IBM/4.3 (AOS)
+Motorola Delta 88K	SVR3.2
+Decstation 3100		Ultrix 4.3
+Dec 4000 Alpha AXP	DEC OSF/1 V1.3
+386			ISC UNIX 3.0.1
+386			FreeBSD 1.1
+IBM RS/6000		AIX 3.2
+Amiga			Amiga UNIX 2.1
+Sony NEWS 841		NEWS OS
+HP 9000/834		HP/UX 7.0

CWRU/POSIX.NOTES

@@ -0,0 +1,63 @@
+Starting bash with the `-posix' command-line option or setting the variable
+POSIXLY_CORRECT while bash is running will cause bash to conform more
+closely to the Posix.2 standard by changing the behavior to match that
+specified by Posix.2 in areas where the bash default differs.
+
+The following list is what's changed when `posixly_correct' is enabled:
+
+1.  When a command in the hash table no longer exists, bash will re-search
+    $PATH to find the new location.
+
+2.  The >& redirection does not redirect stdout and stderr.
+
+3.  The message printed by the job control code and builtins when a job
+    exits with a non-zero status is `Done(status)'.
+
+4.  The <> redirection does not open a file for both stdin and stdout, but
+    rather opens it for read-write on fd 0.
+
+5.  Reserved words may not be aliased.
+
+6.  The Posix.2 PS1 and PS2 expansions of `!' -> history number and `!!' -> `!'
+    are enabled.
+
+7.  Interactive comments are enabled by default.  (Note that this version has
+    them on by default anyway.)
+
+8.  The Posix.2 startup files are executed ($ENV) rather than the normal bash
+    files.
+
+9.  Tilde expansion is only performed on assignments preceding a command name,
+    rather than on all assignment statements on the line.
+
+10. The default history file is ~/.sh_history (default value of $HISTFILE).
+
+11. The output of `kill -l' prints all the signal names on a single line,
+    separated by spaces.
+
+12. Non-interactive shells exit if `file' in `. file' is not found.
+
+13. Redirection operators do not perform pathname expansion on the word
+    in the redirection unless the shell is interactive
+
+14. Function names must be valid shell identifiers.  That is, they may not
+    contain characters other than letters, digits, and underscores, and
+    may not start with a digit
+
+There is other Posix.2 behavior that bash does not implement.  Specifically:
+
+1.  There are no `special builtins' and `regular builtins'.  All builtins
+    are equivalent.  This means that:
+
+	o assignment statements affect the execution environment of all
+	  builtins, not just special ones
+	o temporary assignments do not persist after Posix.2 special
+	  builtins complete
+	o Functions are found before Posix.2 special builtins
+	o The shell does not exit upon errors while executing Posix.2
+	  special builtins
+
+2.  $LINENO does not represent the line number of a command within a function
+
+3.  The arithmetic evaluator does not implement the `e ? e1 : e2' conditional
+    expression

CWRU/README

@@ -0,0 +1,26 @@
+Notes:
+
+ISC 386 machines must compile test.c without -O.  The resultant shell dumps
+core when test is invoked.
+
+There have been reports that SCO 3.2v4.2 requires -DPRGP_PIPE in SCO_CFLAGS,
+and that it has too many -D defines for SCO's cc (rcc works).
+
+Contents of this directory:
+
+CWRU.chlog		- my change log since the last release
+
+KSH.README		- list of similarities with ksh.  Slightly out of date
+
+PLATFORMS.113		- list of platforms I have built this release on
+
+POSIX.NOTES		- list of what changes for `posix mode'
+
+README			- this file
+
+RSH.README		- explanation of the bash `restricted shell' mode
+
+
+misc			- directory with some useful tools
+OS-BUGS			- directory with messages detailing some OS bugs and
+			  the bash workarounds

CWRU/changelog

@@ -0,0 +1,786 @@
+				    6/2
+				    ---
+lib/readline/readline.c
+	- fixed an off-by-one error in the kill ring reallocation code
+	  in rl_kill_text
+
+Makefile
+	- replaced instances of /bin/sh with $(SHELL)
+
+Makefile, cpp-Makefile, documentation/Makefile
+	- added a working `uninstall' target
+
+[1.14.0 FCS release made available for FTP]
+
+				    6/3
+				    ---
+README
+	- added note about building with gcc, same as in Makefile
+
+documentation/Makefile
+	- some versions of make don't understand `$*' in a regular recipe;
+	  replace with features.dvi in the recipe for features.ps
+
+				    6/4
+				    ---
+subst.c
+	- fix up the calls to string_extract_double_quoted and 
+	  string_extract_single_quoted in char_is_quoted so the initial
+	  value of the index is *after* the opening quote character
+	- make sure we only return 1 from char_is_quoted if the index
+	  into the string after a call to string_extract_double_quoted or
+	  string_extract_single_quoted is *greater than* `eindex'
+
+lib/readline/complete.c
+	- change the order and sense of the quoting tests in
+	  rl_complete_internal so that the expensive char_is_quoted
+	  is only called if `scan' actually is a word break character
+
+shell.c
+	- fixed a typo in the test for a restricted shell
+
+builtins/exec.def
+	- need to include flags.h
+
+				    6/6
+				    ---
+make_cmd.c
+	- make sure that we don't try to walk down a null command tree
+	  in connect_async_list (tickled by `(command &) &')
+	- if a command has the CMD_WANT_SUBSHELL bit set in its flags,
+	  don't even try to walk the command tree and move the `&';
+	  just connect the command with a null command using `&'
+
+execute_cmd.c
+	- make sure we don't try to reference a command struct without
+	  first checking it (case '&')
+
+				    6/7
+				    ---
+machines.h
+	- fix a typo in the NeXT/i386 description; change the NeXT description
+	  to #define HAVE_RESOURCE if not already defined rather than putting
+	  -DHAVE_RESOURCE into the SYSDEP_CFLAGS
+
+				    6/9
+				    ---
+Makefile
+	- make sure all of the rules that reinvoke `make' have the
+	  `-f bash-Makefile' before the assignment statements; some
+	  versions of make like it that way
+
+variables.c
+	- make sure that `interactive' is set to 0 before evaluating the
+	  string containing an exported function obtained from the
+	  environment, so that it does not try to execute PROMPT_COMMAND
+	  (this may not be the best fix)
+
+				   6/13
+				   ----
+documentation/Makefile
+	- make sure all of the directories exist before trying to install
+	  doc files into them
+
+lib/readline/history.c
+	- add a missing O_TRUNC to the open call for writing in
+	  history_truncate_file
+
+trap.c
+	- run_interrupt_trap should only try to run the trap command if
+	  the value is not IMPOSSIBLE_TRAP_HANDLER
+
+Makefile
+	- add `realclean'
+
+lib/readline/complete.c
+	- do the same kind of double-quoting a replacement string if the
+	  user supplies the opening double quote as we would if we were
+	  adding both quotes ourselves
+
+variables.c
+	- fixed the variable initialization so that history_control/HISTCONTROL
+	  can be inherited from a parent shell
+
+INSTALL, README, cpp-Makefile, documentation/bash.1, documentation/readline.3
+	- ai.mit.edu -> prep.ai.mit.edu
+
+shell.c
+	- fixed a problem with setting no_line_editing to the result of the
+	  check for running inside emacs, thereby losing any value
+	  initialized by the `-nolineediting' flag
+
+cpp-Makefile
+	- `make distclean' will now remove the `installed-bash' link
+
+print_cmd.c
+	- fixed a problem with undefined variables when HAVE_VARARGS_H is
+	  not defined
+
+				   6/14
+				   ----
+lib/readline/history.c
+	- fixed an error in the csh history expansion code so that the
+	  `-y' word designator now expands to `0-y' rather than `1-y'
+
+lib/readline/isearch.c
+	- changed an absolute check for a character falling within the
+	  ASCII 32-126 range (printable chars) with checks for CTRL_P
+	  and META_CHAR and a check against the value RUBOUT
+	- changed a `break' to a `continue' so that the first non-matching
+	  character in the search string does not cause the search to
+	  end abruptly
+	- initialize prev_line_found to 0 at the top of rl_search_history
+	  to avoid duplicate history lines being saved across searches
+
+lib/readline/rltty.c
+	- consolidated repeated code for setting special characters into
+	  `SET_SPECIAL' defines
+
+lib/readline/readline.c
+	- include <sys/ioctl.h> if VSTATUS is defined
+	- add bindable command rl_tty_status (unbound by default)
+
+lib/readline/funmap.c
+	- assign bindable command name `tty-status' to rl_tty_status
+
+INSTALL
+	- add note about compiling with gcc, same text as README
+
+lib/readline/display.c
+	- many changes and tweaks to make redisplay work better when the
+	  prompt has invisible characters.  These changes are non-optimal
+	  in that the prompt is redrawn more than it needs to be, but
+	  things are a hell of a lot better than they were
+
+				   6/15
+				   ----
+documentation/Makefile
+	- make a variable NROFF that people can set to `groff -Tascii' if
+	  they don't have real nroff
+	- changed the suffix rules to use $<
+
+support/bashbug.sh
+	- if rmail doesn't exist or fails, save the bug report in
+	  ~/dead.bashbug
+
+execute_cmd.c
+	- in setup_async_signals, only ignore SIGINT and SIGQUIT if job
+	  control is not active.  If it is active and the job is restarted,
+	  SIGINT remains ignored, and the now-foregrounded job is not
+	  interruptible
+
+subst.c
+	- fixed up a problem with char_is_quoted that caused backslash-
+	  escaped characters to cause incorrect results
+
+tests/run-dollars, tests/dollar-at.sh, tests/dollar-star.sh
+	- since the error messages produced by `cat' vary, changed `cat'
+	  to `recho' and updated the correct answers file
+
+machines.h
+	- fixes to CRAY_STACKSEG_END definitions for different versions of
+	  Unicos on the YMP (from Bill Jones)
+	- Motorola SVR4 machines have getcwd() and should not undef
+	  HAVE_GETCWD
+	- on hpux 9.x, don't try to link with -lPW if compiling with gcc
+	  (for alloca)
+
+parse.y
+	- an ugly fix for a compiler problem with structure assignment on
+	  the cray
+
+				   6/16
+				   ----
+builtins/wait.def
+	- replaced a call to sscanf with a validity check using all_digits()
+	  and a call to atoi, since a pid_t is not necessarily an int, and
+	  the sscanf clobbered the stack frame on systems where it is shorter
+	  than an int (e.g., SCO)
+
+lib/readline/display.c
+	- since META_CHAR and the other macros only work with unsigned
+	  chars, make rl_character_len convert its argument to an unsigned
+	  char before testing it
+
+documentation/Makefile
+	- use $(INSTALL_DATA) instead of $(CP) to install the man pages and
+	  info files
+
+cpp-Makefile
+	- use INSTALL_PROGRAM and INSTALL_DATA to install binaries and
+	  documentation; pass both values to installs in subdirectories
+
+				   6/18
+				   ----
+builtins/ulimit.def
+	- compensate for systems which define RLIMIT_OFILE instead of
+	  RLIMIT_NOFILE, or don't provide such a compatibility define
+	  themselves
+
+shell.c
+	- make maybe_execute_file check for directories and print an
+	  appropriate error message, since it's doing an fstat anyway
+
+support/mksysdefs
+	- added support for a `-s srcdir' option so it can find
+	  cpp-Makefile if ansi-Makefile is to be created
+
+Makefile
+	- call mksysdefs with -s $(srcdir)
+
+jobs.c
+	- add the magic #undef lines to avoid redefinition warnings on
+	  SunOS 4 only
+
+				   6/20
+				   ----
+cpp-Makefile
+	- install `bashbug' with `make install'
+
+trap.c
+	- make sure that `interactive' is set to 0 when running trap
+	  commands
+
+builtins/umask.c
+	- fixed typo in usage error message
+
+subst.c
+	- fix process_substitute to set subshell_environment
+
+jobs.c, nojobs.c
+	- only mess with the terminal settings for an interactive shell
+	  that is not in a subshell environment
+
+				   6/21
+				   ----
+lib/readline/history.h
+	- add extern declaration of history_get
+
+builtins/fc.def
+	- make history replacement when using `r' or `fc -s' obey the
+	  setting of HISTCONTROL
+
+general.c
+	- in canonicalize_pathname, preserve a double // at the start
+	  of an absolute pathname, since that means something special
+	  for the network directory system
+
+README, INSTALL
+	- updated information about submitting bug reports
+
+lib/readline/vi_mode.c, lib/readline/isearch.c
+	- make sure unistd.h is included before rldefs.h, if
+	  HAVE_UNISTD_H is defined
+
+				   6/24
+				   ----
+lib/readline/complete.c
+	- add `#' to the list of characters which cause a completed filename
+	  to be quoted
+
+execute_cmd.c
+	- be more careful about closing pipe file descriptors in do_piping;
+	  don't want to have `dup2(i, i); close(i);' problem
+
+lib/readline/{keymaps,readline}.h
+	- include local copies of include files if READLINE_LIBRARY is
+	  defined, otherwise include the `official, installed' versions
+	  using #include <readline/xxx.h>
+
+lib/readline/*.c
+	- define READLINE_LIBRARY before including any files
+	- include only `local' copies of include files using #include "xxx.h"
+	  rather than #include <readline/xxx.h>
+
+				   6/26
+				   ----
+execute_cmd.c
+	- check for clobbering the bash input stream before closing a file
+	  descriptor due to an r_close_this redirection
+
+lib/readline/history.c
+	- made history_expand inhibit history expansion if the history
+	  expansion char is set to 0
+
+lib/readline/chardefs.h
+	- moved savestring() definition to rldefs.h
+	- changed lowercase_p, uppercase_p, to_lower, to_upper defines to
+	  use <ctype.h> macros rather than assume ASCII
+
+lib/readline/bind.c, general.c, general.h
+	- use strcasecmp, strncasecmp instead of str[n]icmp if
+	  HAVE_STRCASECMP is defined
+
+cpp-Makefile
+	- pass -DHAVE_STRCASECMP to builds in the libraries, primarily
+	  readline
+
+machines.h
+	- add HAVE_STRCASECMP to the entries for BSD/386, NetBSD, FreeBSD,
+	  and 4.4 BSD
+
+builtins/hash.def
+	- add a fourth parameter to remember_filename, the initial value
+	  of times_found (0 if we're just looking it up for `hash', 1
+	  for the command execution code)
+
+execute_cmd.c
+	- call remember_filename with an initial value of 1 for times_found
+
+builtins/wait.def
+	- handle a null argument with an error message
+
+builtins/common.c
+	- parse_and_execute now takes a third parameter: the value for
+	  `interactive' while it is executing commands
+
+bashline.c, jobs.c, parse.y, shell.c, subst.c, trap.c, variables.c
+	- set the new third argument to parse_and_execute appropriately
+
+builtins/eval.def, builtins/fc.def, builtins/source.def
+	- set the new third argument to parse_and_execute appropriately
+
+builtins/help.def
+	- changed a call to strnicmp to strncmp when trying to find what
+	  to give help on; it seems more correct
+
+				   6/27
+				   ----
+machines.h
+	- cleaned up the SunOS section so it no longer relies on
+	  HAVE_SHARED_LIBS being defined; it uses SunOS4 and SunOS5
+	  instead
+
+support/mksysdefs
+	- define SYSDEF to be SunOS4 or SunOS5 depending on the output
+	  of uname rather than looking for ld.so
+
+				   6/29
+				   ----
+machines.h
+	- minor change to the ardent titan machine description
+	- move the ardent and stardent descriptions before the
+	  mips riscos description
+
+print_cmd.c
+	- ardent machines also need the extern declaration for printf
+
+make_cmd.c
+	- connect_async_list should do its work only if the lists to be
+	  backgrounded are connected with `;'.  This makes `;' bind tighter
+	  than `&', so only the last job in the list is backgrounded.  All
+	  other lists should have the entire thing put in the background
+
+parse.y
+	- added a function `print_prompt' to take care of displaying the
+	  prompt string if readline is not being used.  This fixes problems
+	  with the prompt being displayed before the status of completed
+	  jobs is printed
+
+				   6/30
+				   ----
+builtins/fg_bg.def
+	- `fg' and `bg' now print error messages if invoked when job control
+	  is disabled
+
+lib/readline/rltty.c
+	- if not compiled into the shell, make get_tty_settings get and set
+	  the window size.  This noop stops the process if it is started in
+	  the background
+
+lib/readline/readline.c
+	- provide a function version of savestring, if not being compiled
+	  into the shell, since the macro has been removed from the
+	  `public' header files
+
+lib/readline/readline.h
+	- provide all extern function declarations without checking whether
+	  VI_MODE or PAREN_MATCHING are defined.  It does not hurt to define
+	  them if they are not used and not in the library, and other
+	  applications using readline can't tell whether or not VI_MODE was
+	  defined when the library was compiled anyway
+
+				    7/1
+				    ---
+machines.h
+	- add #undef HAVE_DIRENT_H to the ardent titan description
+
+				    7/2
+				    ---
+lib/readline/chardefs.h
+	- removed META_P define, renamed CTRL_P to CTRL_CHAR
+
+lib/readline/bind.c, lib/readline/isearch.c
+	- changed instances of CTRL_P to CTRL_CHAR
+
+lib/readline/search.c
+	- include <unistd.h> before rldefs.h, if HAVE_UNISTD_H is defined
+
+lib/readline/readline.c
+	- declare PC, UP, and BC as extern rather than `local' to the
+	  readline library
+
+				    7/5
+				    ---
+bashline.c
+	- implement command word completion inside of command substitution
+	  with a new function: `command_subst_completion_function'
+
+subst.c
+	- new function to help with command subst completion: unclosed_pair
+
+lib/readline/complete.c
+	- new variable rl_filename_quoting_desired, which can be set to 0
+	  to inhibit the quoting of filenames after completion
+
+lib/readline/readline.h
+	- declare rl_filename_completion_desired and
+	  rl_filename_quoting_desired
+
+builtins/bind.def
+	- don't save the old value of rl_outstream before initializing
+	  readline -- it saves garbage values and screws up readline
+
+parse.y
+	- don't have private state telling whether or not readline has
+	  been initialized -- use bash_readline_initialized like other
+	  functions in bashline.c
+
+lib/readline/readline.c
+	- make the default 8-bit behavior be based on whether LC_CTYPE is
+	  defined and its value (accept iso-8859-1 or iso_8859_1)
+
+				    7/6
+				    ---
+variables.c
+	- fix up the declaration of getenv() for convex machines
+
+				    7/7
+				    ---
+lib/readline/readline.c
+	- fixed up typos in the declaration of `savestring'
+
+lib/readline/history.c
+	- fixed an off-by-one error in the ADD_CHAR macro which caused one
+	  extra character to be overwritten, causing the gnu malloc to abort
+	  when that one character was at the end of an allocated block
+	- changed the ADD_STRING macro to avoid some unnecessary xreallocs
+
+lib/readline/display.c
+	- fixed a problem with move_cursor_relative -- function now returns
+	  immediately if it has nothing to do
+	- fixed another problem with displaying prompts with invisible chars
+
+lib/readline/chardefs.h
+	- fixed the CTRL macro to be right (agree with the BSD kernel, for
+	  example)
+
+cpp-Makefile
+	- fixed typo in the `install' recipe
+
+				    7/8
+				    ---
+support/srcdir
+	- fixed to handle srcdir when it begins with ./ or ../ to handle
+	  $(srcdir) being a relative path better
+
+cpp-Makefile
+	- changed some include paths to $(BUILTIN_ABSSRC) when building in
+	  `builtins' to handle $(srcdir) being a relative path
+	- change the `chmod' on bashbug to turn on read and execute for all
+	- added a couple of definitions to make it easier for a later
+	  `configure' program
+
+support/mksysdefs
+	- added a -i option to specify an alternate set of directories to
+	  search for include files
+
+lib/readline/bind.c
+	- in rl_read_init_file, when skipping whitespace at the start of
+	  the line, decrement `i' so that we don't jump past the start
+	  of the next line
+
+machines.h
+	- SCOv4 has a `robust' opendir that checks that you're actually
+	  opening a directory
+
+				   7/11
+				   ----
+lib/readline/complete.c
+	- make sure a word break character is unquoted before using it to
+	  separate out the current word for completing
+
+machines.h
+	- new machine description: NetBSD on motorola m68k machines like
+	  the hp300
+	- undef HAVE_GETWD in the generic svr4 machine description, like
+	  other svr4 descriptions
+
+lib/readline/rltty.c
+	- make sure to fflush (rl_outstream) after toggling the setting
+	  of the keypad and meta key
+
+portbash/libc.sh
+	- add a test for OPENDIR_NOT_ROBUST
+
+support/getcppsyms.c
+	- output __svr4__ if we find __uxps__ (this makes the Fujitsu port of
+	  SVR4 to the sparc build OK)
+
+				   7/12
+				   ----
+lib/readline/display.c
+	- more display-related fixes when the prompt has invisible chars;
+	  this time for screen updates when moving between screen lines
+
+lib/readline/readline.c, lib/readline/display.c
+	- changes to make readline work with terminals that have auto-wrap
+	  from Per Bothner (new function _rl_update_final, term_xn changes,
+	  some efficiency speedups, new function space_to_eol)
+
+				   7/13
+				   ----
+lib/readline/display.c
+	- after moving up screen lines using term_up in _rl_move_vert, if
+	  the new screen line is 0, _rl_last_c_pos needs to be adjusted
+	  to take invisible characters into account.  This was the source
+	  of many bugs
+
+				   
+				   7/14
+				   ----
+documentation/Makefile
+	- change instances of `groff' to `${GROFF}', GROFF is set to
+	  `groff' by default
+
+general.c, variables.c
+	- moved `qsort_string_compare' from variables.c to general.c
+
+general.h, variables.h
+	- moved declaration of `qsort_string_compare' from variables.h
+	  to general.h
+
+alias.c, lib/readline/funmap.c
+	- moved qsort auxiliary functions after their use and added
+	  forward declarations to avoid warnings from ANSI C compilers
+
+memalloc.h
+	- hpux_9 needs alloca declared as `extern void *' if __STDC__
+	  is defined
+
+support/mksysdefs
+	- removed HAVE_SHARED_LIBS entirely
+	- make a call to /bin/uname -X for SCO machines to avoid running
+	  a different uname from the $PATH
+
+machines.h
+	- new descriptions: Intel i860 running SVR4, Tahoe running 4.3 BSD
+	- changed descriptions: Mips/RiscOS, DG AViiON, unknown machine
+
+jobs.c
+	- changes to how the shell handles foreground jobs dying of SIGINT:
+		an interactive shell using job control will no longer
+		act as if it received a SIGINT if the foreground job
+		dies from a SIGINT
+
+		a non-interactive shell or shell without job control tries
+		to differentiate between SIGINTs it has seen (in
+		wait_sigint_handler) and a foreground job dying of a SIGINT
+		not sent from the keyboard, and runs the normal SIGINT code
+		only in the former case
+
+				   7/15
+				   ----
+support/mksysdefs
+	- check for ${UNAME}${RELEASE} expanding to `SunOS4*' or `SunOS5*'
+	  to set SYSDEF to SunOS4 or SunOS5, respectively.  Apparently
+	  this does not work for Solbourne
+
+				   7/18
+				   ----
+
+lib/readline/rltty.c
+	- if output is being flushed on termios systems, loop until the
+	  FLUSHO bit is no longer set in the termios struct
+
+support/mksysdefs
+	- added a -A flag to force creation of ansi-Makefile
+
+machines.h
+	- new entry for Tandem machines running SVR3
+
+				   7/19
+				   ----
+lib/readline/rldefs.h
+	- include <termcap.h> if HAVE_TERMCAP_H is defined
+	- use <termio.h> stuff if HAVE_TERMIO_H is defined and _POSIX_VERSION
+	  is not defined
+
+lib/readline/rldefs.h, lib/readline/history.c
+	- include "config.h" if HAVE_CONFIG_H is defined
+
+lib/readline/{rldefs.h,signals.c,readline.c}
+	- WINSIZE_IN_IOCTL_H -> GWINSZ_IN_SYS_IOCTL for compatibility with
+	  other GNU programs
+
+lib/readline/doc/Makefile
+	- fixed up to create the readline and history manuals in dvi and
+	  ps format
+
+lib/readline/Makefile
+	- changes inspired by the standalone readline-2.0 distribution
+
+				   7/20
+				   ----
+lib/readline/history.c
+	- new function, history_is_stifled (), returns history_stifled
+	- set history_state flags member in the history state functions
+
+lib/readline/history.h
+	- reorganized the function declarations, added missing declarations
+	- history_stifled is no longer exported by the library
+	- added a `flags' member to the HISTORY_STATE structure
+
+bashline.c
+	- use history_is_stifled () instead of history_stifled
+
+lib/readline/readline.c, lib/readline/vi_mode.c
+	- filled in correct argument declarations for functions called via
+	  keymaps (count, key)
+
+lib/readline/complete.c
+	- efficiency improvement for compare_strings
+
+				   7/21
+				   ----
+examples/dirfuncs
+	- new directory functions from ksh book, contributed by
+	  Ken Konecki (kenk@wfg.com)
+
+machines.h
+	- hpux_8 and hpux_9 should both #undef HAVE_ALLOCA unless gcc is
+	  being used
+
+				   7/22
+				   ----
+bashline.c
+	- fixed up command_word_completion_function so that filenames with
+	  leading tildes are completed correctly
+
+				   7/26
+				   ----
+builtins/read.def
+	- if -r not given, make sure CTLESC is removed from input string
+	  when reading \<newline>
+
+lib/readline/readline.c
+	- new function bind_arrow_keys, which binds vt100/ansi arrow key
+	  escape sequences after reading the termcap definition and the
+	  inputrc file
+	- new function rl_yank_last_arg, which does what insert-last-arg
+	  does in bash
+
+lib/readline/emacs_keymap.c
+	- remove default bindings to rl_arrow_keys for M-[ and M-O
+	- rl_yank_last_arg is now bound to `M-.' and `M-_' in
+	  emacs_meta_keymap
+
+subst.c
+	- when performing process substitution on systems with /dev/fd,
+	  make sure the child clears the slot in dev_fd_list it gets
+	  from its parent so the file descriptor does not get closed
+	  inappropriately if reallocated by, e.g., pipe(2)
+
+bashline.c
+	- removed insert_last_arg and the calls to bind in to `M-.' and `M-_'.
+	  `insert-last-argument' is now bound to rl_yank_last_arg for
+	  backwards compatibility
+
+lib/readline/funmap.c
+	- `yank-last-arg' is now a named command for rl_yank_last_arg
+
+
+documentation/bash.1, documentation/readline.3
+	- add description of yank-last-arg as one of the readline user
+	  commands
+
+lib/readline/doc/rluser.texinfo
+	- added description of yank-last-arg
+
+builtins/getopts.def
+	- fixed a typo in the int-to-string code computing the value to set
+	  OPTIND to: had '\0' instead of '0'
+	- made getopts handle the case where there are more than 9 dollar
+	  variables (where rest_of_args is non-null) correctly
+
+				   7/28
+				   ----
+lib/readline/display.c
+	- fixes to the display code for single-line-display in the presence
+	  of prompts containing invisible characters
+
+lib/readline/readline.c
+	- if we are using horizontal scrolling and we have term_xn, decrement
+	  the screenwidth by 1, since we won't be doing any line wrapping
+
+				   7/31
+				   ----
+jobs.c
+	- new variable `freeze_jobs_list' to set when changes to the jobs
+	  list or status of jobs in the list (other than calling something
+	  like `jobs -n') are undesirable.  This is set when execuing traps
+	  on SIGCHLD
+
+				    8/1
+				    ---
+subst.c
+	- check that `~' is unquoted before performing tilde expansion in
+	  an assignment statement
+
+				    8/3
+				    ---
+bracecomp.c
+	- keep brace completion from dumping core if there is only one
+	  match
+
+lib/readline/chardefs.h
+	- add a define for digit_p, which returns the value of isdigit()
+
+lib/readline/readline.c
+	- added function equivalents for uppercase_p, lowercase_p, to_upper,
+	  to_lower, pure_alphabetic, digit_p, and digit_value
+	- replaced calls to numeric () with calls to digit_p, removed
+	  definition of numeric ()
+
+lib/readline/history.c
+	- digit -> digit_p
+
+lib/readline/vi_mode.c
+	- replaced uses of the `isletter' define to use pure_alphabetic
+	  from chartypes.h
+	- replaced uses of `numeric' with calls to digit_p
+	- added do...while(0) to `exchange' define
+
+				    
+				    8/4
+				    ---
+execute_cmd.c
+	- make sure execute_function saves and restores the current loop
+	  count with unwind_protect_int
+
+documentation/features.texi
+	- change the `Shell Command Line Options' section to `Invoking
+	  Bash' to be closer to the GNU coding standards
+
+				    8/5
+				    ---
+builtins/read.def
+	- fixed up a memory leak and made behavior correct when no
+	  variables given and backslash escaped at least one input char
+	- if we added CTLESC anywhere while reading the input string,
+	  make sure we call dequote_string on each word of the input
+	  before calling bind_variable with that string
+
+subst.c
+	- made an efficiency improvement to dequote_string -- don't
+	  do anything when we see CTLESC, just `continue' the loop

CWRU/misc/aux-mach-desc

@@ -0,0 +1,20 @@
+/* ************************ */
+/*                        */
+/*    A/UX 3.0 System     */
+/*                        */
+/* ************************ */
+#if defined (mc68k32) && !defined (M_MACHINE)
+#  define M_MACHINE "Macintosh"
+#  define M_OS "AUX"
+#  define SYSDEP_CFLAGS -ZP -DUSG -DHAVE_BCOPY -DHAVE_UID_T -DNSIG=32 \
+			-DHAVE_GETDTABLESIZE
+#  define SYSDEP_LDFLAGS -ZP
+#  define HAVE_DIRENT
+#  define HAVE_POSIX_SIGNALS
+#  define HAVE_VFPRINTF
+#  define VOID_SIGHANDLER
+#  define HAVE_GETGROUPS
+#  undef HAVE_RESOURCE
+#  undef HAVE_ALLOCA
+#  define REQUIRED_LIBRARIES -lc_s
+#endif /* A/UX */

CWRU/misc/bison

@@ -0,0 +1,7 @@
+#! /bin/sh
+
+if [ "$1" = '-y' ]; then
+	shift
+fi
+
+exec /usr/bin/yacc ${1+"$@"}

CWRU/misc/open-files.c

@@ -0,0 +1,16 @@
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/file.h>
+#include <stdio.h>
+
+main()
+{
+	register int	i;
+
+	for (i = 0; i < getdtablesize(); i++) {
+		if (fcntl(i, F_GETFD, 0) != -1)
+			fprintf(stderr, "fd %d: open\n", i);
+	}
+	exit(0);
+}
+

CWRU/misc/pid.c

@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+main()
+{
+	fprintf(stderr, "%d\n", getpid());
+	exit(0);
+}

CWRU/misc/sigs.c

@@ -0,0 +1,27 @@
+#include <signal.h>
+#include <stdio.h>
+
+extern char	*sys_siglist[];
+
+typedef void	sighandler();
+
+main(argc, argv)
+int	argc;
+char	**argv;
+{
+	register int	i;
+	sighandler	*h;
+
+	for (i = 1; i < NSIG; i++) {
+		h = signal(i, SIG_DFL);
+		if (h != SIG_DFL) {
+			if (h == SIG_IGN)
+				fprintf(stderr, "%d: ignored (%s)\n", i, sys_siglist[i]);
+			else
+				fprintf(stderr, "%d: caught (%s)\n", i, sys_siglist[i]);
+		}
+	}
+	exit(0);
+}
+
+		

CWRU/misc/sigstat.c

@@ -0,0 +1,206 @@
+/*
+ * sigstat - print out useful information about signal arguments
+ *
+ */
+
+#include <sys/types.h>
+#include <signal.h>
+#include <stdio.h>
+
+extern char	*strrchr();
+static char	*signames[NSIG];
+
+char	*progname;
+
+void	sigstat();
+
+main(argc, argv)
+int	argc;
+char	**argv;
+{
+	register int	i;
+	char	*t;
+
+	if (t = strrchr(argv[0], '/'))
+		progname = ++t;
+	else
+		progname = argv[0];
+	init_signames();
+	if (argc == 1) {
+		for (i = 1; i < NSIG; i++)
+			sigstat(i);
+		exit(0);
+	}
+	for (i = 1; i < argc; i++)
+		sigstat(atoi(argv[i]));
+	exit(0);
+}
+
+void
+sigstat(sig)
+int	sig;
+{
+	struct sigaction oact;
+	char *signame;
+	sigset_t set, oset;
+	int blocked;
+
+	if (sig < 0 || sig >= NSIG) {
+		fprintf(stderr, "%s: %d: signal out of range\n", progname, sig);
+		return;
+	}
+	signame = signames[sig];
+	sigemptyset(&oset);
+	sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset);
+	if (sigismember(&oset, sig))
+		printf("%s: signal is blocked\n", signame);
+	sigaction(sig, (struct sigaction *)NULL, &oact);
+	if (oact.sa_handler == SIG_IGN)
+		printf("%s: signal is ignored\n", signame);
+	else if (oact.sa_handler == SIG_DFL)
+		printf("%s: signal is defaulted\n", signame);
+	else
+		printf("%s: signal is trapped (?)\n", signame);
+}
+
+init_signames()
+{
+	register int i;
+	bzero(signames, sizeof(signames));
+
+#if defined (SIGHUP)		/* hangup */
+  	signames[SIGHUP] = "SIGHUP";
+#endif
+#if defined (SIGINT)		/* interrupt */
+  	signames[SIGINT] = "SIGINT";
+#endif
+#if defined (SIGQUIT)		/* quit */
+  	signames[SIGQUIT] = "SIGQUIT";
+#endif
+#if defined (SIGILL)		/* illegal instruction (not reset when caught) */
+  	signames[SIGILL] = "SIGILL";
+#endif
+#if defined (SIGTRAP)		/* trace trap (not reset when caught) */
+  	signames[SIGTRAP] = "SIGTRAP";
+#endif
+#if defined (SIGABRT)		/*  */
+  	signames[SIGABRT] = "SIGABRT";
+#endif
+#if defined (SIGIOT)		/* IOT instruction */
+  	signames[SIGIOT] = "SIGIOT";
+#endif
+#if defined (SIGEMT)		/* EMT instruction */
+  	signames[SIGEMT] = "SIGEMT";
+#endif
+#if defined (SIGFPE)		/* floating point exception */
+  	signames[SIGFPE] = "SIGFPE";
+#endif
+#if defined (SIGKILL)		/* kill (cannot be caught or ignored) */
+  	signames[SIGKILL] = "SIGKILL";
+#endif
+#if defined (SIGBUS)		/* bus error */
+  	signames[SIGBUS] = "SIGBUS";
+#endif
+#if defined (SIGSEGV)		/* segmentation violation */
+  	signames[SIGSEGV] = "SIGSEGV";
+#endif
+#if defined (SIGSYS)		/* bad argument to system call */
+  	signames[SIGSYS] = "SIGSYS";
+#endif
+#if defined (SIGPIPE)		/* write on a pipe with no one to read it */
+  	signames[SIGPIPE] = "SIGPIPE";
+#endif
+#if defined (SIGALRM)		/* alarm clock */
+  	signames[SIGALRM] = "SIGALRM";
+#endif
+#if defined (SIGTERM)		/* software termination signal from kill */
+  	signames[SIGTERM] = "SIGTERM";
+#endif
+#if defined (SIGCLD)		/* Like SIGCHLD.  */
+  	signames[SIGCLD] = "SIGCLD";
+#endif
+#if defined (SIGPWR)		/* Magic thing for some machines. */
+  	signames[SIGPWR] = "SIGPWR";
+#endif
+#if defined (SIGPOLL)		/* For keyboard input?  */
+  	signames[SIGPOLL] = "SIGPOLL";
+#endif
+#if defined (SIGURG)		/* urgent condition on IO channel */
+  	signames[SIGURG] = "SIGURG";
+#endif
+#if defined (SIGSTOP)		/* sendable stop signal not from tty */
+  	signames[SIGSTOP] = "SIGSTOP";
+#endif
+#if defined (SIGTSTP)		/* stop signal from tty */
+  	signames[SIGTSTP] = "SIGTSTP";
+#endif
+#if defined (SIGCONT)		/* continue a stopped process */
+  	signames[SIGCONT] = "SIGCONT";
+#endif
+#if defined (SIGCHLD)		/* to parent on child stop or exit */
+  	signames[SIGCHLD] = "SIGCHLD";
+#endif
+#if defined (SIGTTIN)		/* to readers pgrp upon background tty read */
+  	signames[SIGTTIN] = "SIGTTIN";
+#endif
+#if defined (SIGTTOU)		/* like TTIN for output if (tp->t_local&LTOSTOP) */
+  	signames[SIGTTOU] = "SIGTTOU";
+#endif
+#if defined (SIGIO)		/* input/output possible signal */
+  	signames[SIGIO] = "SIGIO";
+#endif
+#if defined (SIGXCPU)		/* exceeded CPU time limit */
+  	signames[SIGXCPU] = "SIGXCPU";
+#endif
+#if defined (SIGXFSZ)		/* exceeded file size limit */
+  	signames[SIGXFSZ] = "SIGXFSZ";
+#endif
+#if defined (SIGVTALRM)		/* virtual time alarm */
+  	signames[SIGVTALRM] = "SIGVTALRM";
+#endif
+#if defined (SIGPROF)		/* profiling time alarm */
+  	signames[SIGPROF] = "SIGPROF";
+#endif
+#if defined (SIGWINCH)		/* window changed */
+  	signames[SIGWINCH] = "SIGWINCH";
+#endif
+#if defined (SIGLOST)		/* resource lost (eg, record-lock lost) */
+  	signames[SIGLOST] = "SIGLOST";
+#endif
+#if defined (SIGUSR1)		/* user defined signal 1 */
+  	signames[SIGUSR1] = "SIGUSR1";
+#endif
+#if defined (SIGUSR2)		/* user defined signal 2 */
+  	signames[SIGUSR2] = "SIGUSR2";
+#endif
+#if defined (SIGMSG)	/* HFT input data pending */
+  	signames[SIGMSG] = "SIGMSG";
+#endif
+#if defined (SIGPWR)	/* power failure imminent (save your data) */
+  	signames[SIGPWR] = "SIGPWR";
+#endif
+#if defined (SIGDANGER)	/* system crash imminent */
+  	signames[SIGDANGER] = "SIGDANGER";
+#endif
+#if defined (SIGMIGRATE)	/* migrate process to another CPU */
+  	signames[SIGMIGRATE] = "SIGMIGRATE";
+#endif
+#if defined (SIGPRE)	/* programming error */
+  	signames[SIGPRE] = "SIGPRE";
+#endif
+#if defined (SIGGRANT)	/* HFT monitor mode granted */
+  	signames[SIGGRANT] = "SIGGRANT";
+#endif
+#if defined (SIGRETRACT)	/* HFT monitor mode retracted */
+  	signames[SIGRETRACT] = "SIGRETRACT";
+#endif
+#if defined (SIGSOUND)	/* HFT sound sequence has completed */
+  	signames[SIGSOUND] = "SIGSOUND";
+#endif
+
+	for (i = 0; i < NSIG; i++)
+		if (signames[i] == (char *)NULL) {
+			signames[i] = (char *)malloc (16);;
+			sprintf (signames[i], "signal %d", i);
+	  	}
+}

CWRU/sh-redir-hack

@@ -0,0 +1,15 @@
+Add to `subshell' production in parse.y and recompile -DREDIRECTION_HACK to
+get `< xx (command)' sh compatibility.
+
+	|	redirections '(' list ')'
+			{
+#if defined (REDIRECTION_HACK)
+			  /* XXX - C News sh compatibility hack - XXX */
+			  $3->redirects = $1;
+			  $3->flags |= CMD_WANT_SUBSHELL;
+			  $$ = $3;
+#else
+			  yyerror ();
+			  YYABORT;
+#endif
+			}

INSTALL

@@ -0,0 +1,212 @@
+File: bash.info,  Node: Install,  Next: Invoke,	 Prev: Built-in,  Up: Top
+
+Installing BASH
+***************
+
+To install BASH you simply type `make'.	 The BASH `Makefile' tries
+to dynamically figure out what kind of machine and operating system
+you are using.	It makes an educated guess based on the information
+it finds.
+
+During the `make' process, a message is displayed describing what
+machine and operating system has been chosen for you.  This
+information is also saved in the file `.machine' so you can look at
+it later.
+
+Therefore, for most machines, simply follow this simple checklist
+to install BASH:
+
+  1. Type `make'.  If you want to use GCC to compile bash, type
+     `make CC=gcc CPPNAME='$(CC) -E''.
+
+  2. Wait for the compilation to finish.
+
+  3. Type `./bash' to see if the compile worked.
+
+  4. Type `make install prefix=/usr/gnu/' (or the appropriate root
+     of your local GNU software installation tree) to copy bash to
+     your binaries directory, assumed to be ${prefix}/bin.  This will
+     also attempt to install the manual pages under ${prefix}/man
+     and the info file under ${prefix}/info.
+
+* Menu:
+
+* Problems::  What to do if BASH doesn't install quite so easily.
+
+* Files::     Files used in the `make' process.
+
+* Porting::   Porting BASH to a new machine.
+
+* Bugs::      What to do if you Discover Bugs in BASH.
+
+ 
+File: bash.info,  Node: Problems,  Next: Files,	 Prev: Install,	 Up: Install
+
+What if it Doesn't Install so Easily?
+=====================================
+
+Sometimes BASH gets confused and will make the wrong assumptions
+about your machine or operating system.	 If the displayed
+information (also found in `.machine') is incorrect, you will have
+to edit the file `machines.h' and provide the appropriate
+information so that BASH can be installed correctly.  The complete
+instructions for doing this are located in the `machines.h' file.
+
+However, if BASH says that your machine type is an
+"UNKNOWN_MACHINE", or BASH thought it knew something about your
+machine but was wrong, then reading the next few sections could
+be of use to you (*note Files::., and *note Porting::., for more
+information). 
+
+On the MIPSEB with the BSD universe, you must:
+
+1) Place /bsd43/bin in your PATH before /bin
+2) Use $(CC) -E instead of /lib/cpp to build cpp-Makefile.
+
+On SCO Xenix 386, you must:
+
+1) Use $(CC) -E instead of /lib/cpp to build cpp-Makefile.
+
+On Interactive Unix version 3 or 4, you must:
+
+1) Edit cpp-Makefile to remove either -O or -g from DEBUG_FLAGS
+
+File: bash.info,  Node: Files,	Next: Porting,	Prev: Problems,	 Up: Install
+
+Files Used in the `make' Process.
+=================================
+
+The following files are used during the installation of BASH, in
+the `make' process:
+
+`Makefile'
+     This is responsible for making the actual `Makefile' that is
+     used to create Bash.  It runs the C preprocessor (usually
+     located in `/lib/cpp') on the file `cpp-Makefile', producing
+     the output file `bash-Makefile'.
+
+`cpp-Makefile'
+     This is a file of C comments and text.  It contains a
+     reasonable number of `ifdefs' which control what files get
+     compiled and which flags are passed to the various C files
+     comprising BASH.  It includes files named `machines.h',
+     `sysdefs.h', and `config.h'.
+
+`machines.h'
+     This file contains the basic compilation parameters for all of
+     the machines to which BASH has been ported.  This file
+     consists of a series of conditional blocks, one per machine
+     type.
+
+     These conditional blocks are depend upon the unique identifier
+     that `cpp' has predefined for this machine.  In some cases,
+     additional information can be passed from `Makefile'.  It is
+     possible to pass information such as whether or not a
+     particular file is available on this system, and so on.
+
+`sysdefs.h'
+     This file is dynamically made at build time by running the shell
+     script `support/mksydefs'.  If there appears to be something wrong
+     in this file, then edit the `mksysdefs' script, and mail the
+     changes that you make to bash-maintainers@prep.ai.mit.edu.
+
+`bash-Makefile'
+     This is the output from the initial stage of `make'.  It is a
+     stripped down version of `cpp-Makefile' which is tailor-made
+     for your machine and operating system.  All subsequent `makes'
+     use this file.
+
+
+File: bash.info,  Node: Porting,  Next: Bugs,  Prev: Files,  Up: Install
+
+What if You Have to Port to a New Machine?
+==========================================
+
+Sometimes you may want to port BASH to a new, previously
+unsupported machine.  To do so you need to create a block in
+`machines.h' which is conditional based on a unique identifier
+present in your version of the C preprocessor.
+
+If you don't know what that symbol is, you might try the following
+simple test:
+
+     echo "main () { }" > foo.c
+     cc -v foo.c
+
+You are looking for `-DMACHINE', where `MACHINE' is an identifier
+for your machine.  If you are very unlucky and your machine's C
+preprocessor doesn't have a unique identifier, you will have to
+define the identifier in Makefile manually.
+
+Let's say you have a machine from Yoyodyne Industries, called the
+YoYo.  It runs a version of BSD, so it is reasonably compatible. 
+However, the `cpp' on this YoYo machine doesn't define any unique
+identifiers.  You should change the `Makefile' line for `CPPFLAGS'
+to:
+
+     CPPFLAGS = -P -DYoYo
+
+Then, in `machines.h', you copy the block for `UNKNOWN_MACHINE',
+and change the conditional to;
+
+     #if defined (YoYo)
+
+Inside of the YoYo block you define `M_MACHINE="YoYo"', and
+`M_OS=Bsd'.  You also modify the existing defines to match your
+machine's software.
+
+If BASH still won't compile, perhaps because of missing code that
+is required for your YoYo machine, you will have to write that code
+and place it within a conditional block based on YoYo.
+
+Most machines aren't that difficult; simply redefining a few of the
+default values is sufficient.  If you do run across a difficult
+machine, please send all fixes and changes to
+bash-maintainers@prep.ai.mit.edu in the form of context diffs:
+
+     diff -c orig-machines.h machines.h >machines.diffs
+
+Please include information about which version of the shell you have.
+
+For those machines which prove more difficult, or if you are not
+sure about where to start, the scripts in the `portbash' directory
+may prove helpful.
+
+File: bash.info,  Node: Bugs,  Prev: Porting,  Up: Install
+
+Reporting Bugs
+==============
+
+If you find a bug in bash, you should report it.  But first you
+should make sure that it really is a bug and that it appears in the
+latest version of BASH that is available.
+
+Once you have ascertained that a bug really exists, you are welcome
+to mail in a bug report.  If you have a fix, please mail that too!
+The program `bashbug' is used to submit bug reports.
+
+Suggestions and "philosophical" bug reports should be mailed to
+bug-bash@ai.mit.edu.  Genuine bug reports should be mailed to the
+same place, or to bash-maintainers@prep.ai.mit.edu.  The `bashbug'
+script sends its messages to bug-bash@prep.ai.mit.edu.
+
+*All* bug reports should include:
+
+   * The version number of BASH.
+
+   * The hardware and operating system used.
+
+   * The compiler used to compile BASH.
+
+   * A description of the bug's behavior.
+
+   * A short script or "recipe" which demonstrates the bug.
+
+The `bashbug' program includes much of this information
+automatically.  Without this information, it is generally not
+possible to successfully debug BASH.  Usually, without this
+information, the bug won't manifest itself! 
+
+Discussion and questions about BASH in general (including
+questions about this documentation) can be sent to
+bash-maintainers@prep.ai.mit.edu. 

MANIFEST

@@ -0,0 +1,421 @@
+#
+# Master distribution manifest for bash
+#
+#
+# Filename	type
+#
+CWRU		d
+CWRU/misc	d
+builtins	d
+documentation	d
+examples	d
+examples/functions d
+examples/scripts d
+examples/startup-files d
+lib		d
+lib/doc-support	d
+lib/glob	d
+lib/glob/doc	d
+lib/malloc	d
+lib/malloclib	d
+lib/posixheaders d
+lib/readline	d
+lib/readline/doc d
+lib/readline/examples d
+lib/termcap	d
+lib/termcap/grot d
+lib/tilde	d
+lib/tilde/doc	d
+portbash	d
+support		d
+tests		d
+tests/misc	d
+README		f
+RELEASE		f
+INSTALL		f
+COPYING		f
+MANIFEST	f
+configure	f
+Makefile	f
+cpp-Makefile	f
+print_cmd.c	f
+general.c	f
+variables.c	f
+make_cmd.c	f
+copy_cmd.c	f
+unwind_prot.c	f
+dispose_cmd.c	f
+getcwd.c	f
+bashhist.c	f
+hash.c		f
+parse.y		f
+subst.c		f
+shell.c		f
+trap.c		f
+siglist.c	f
+version.c	f
+flags.c		f
+jobs.c		f
+newversion.c	f
+input.c		f
+mailcheck.c	f
+test.c		f
+expr.c		f
+alias.c		f
+execute_cmd.c	f
+bashline.c	f
+braces.c	f
+bracecomp.c	f
+nojobs.c	f
+vprint.c	f
+error.c		f
+signames.c	f
+endian.c	f
+alias.h		f
+config.h	f
+config.h.mini	f
+builtins.h	f
+parser.h	f
+variables.h	f
+machines.h	f
+jobs.h		f
+maxpath.h	f
+filecntl.h	f
+hash.h		f
+quit.h		f
+flags.h		f
+shell.h		f
+trap.h		f
+general.h	f
+unwind_prot.h	f
+input.h		f
+error.h		f
+command.h	f
+externs.h	f
+siglist.h	f
+subst.h	f
+dispose_cmd.h	f
+bashansi.h	f
+make_cmd.h	f
+bashhist.h	f
+execute_cmd.h	f
+bashtypes.h	f
+y.tab.c		f
+y.tab.h		f
+posixstat.h	f
+stdc.h		f
+ansi_stdlib.h	f
+memalloc.h	f
+parser-built	f
+builtins/ChangeLog	f
+builtins/Makefile	f
+builtins/alias.def	f
+builtins/bind.def	f
+builtins/break.def	f
+builtins/builtin.def	f
+builtins/cd.def		f
+builtins/colon.def	f
+builtins/command.def	f
+builtins/common.c	f
+builtins/declare.def	f
+builtins/echo.def	f
+builtins/enable.def	f
+builtins/eval.def	f
+builtins/exec.def	f
+builtins/exit.def	f
+builtins/fc.def		f
+builtins/fg_bg.def	f
+builtins/getopt.c	f
+builtins/getopt.h	f
+builtins/getopts.def	f
+builtins/hash.def	f
+builtins/hashcom.h	f
+builtins/help.def	f
+builtins/let.def	f
+builtins/history.def	f
+builtins/jobs.def	f
+builtins/kill.def	f
+builtins/mkbuiltins.c	f
+builtins/read.def	f
+builtins/reserved.def	f
+builtins/return.def	f
+builtins/set.def	f
+builtins/setattr.def	f
+builtins/shift.def	f
+builtins/source.def	f
+builtins/suspend.def	f
+builtins/test.def	f
+builtins/times.def	f
+builtins/trap.def	f
+builtins/type.def	f
+builtins/ulimit.def	f
+builtins/umask.def	f
+builtins/wait.def	f
+builtins/psize.c	f
+builtins/psize.sh	f
+builtins/inlib.def	f
+builtins/bashgetopt.c	f
+builtins/common.h	f
+builtins/bashgetopt.h	f
+lib/doc-support/texindex.c	f
+lib/doc-support/getopt.h	f
+lib/doc-support/Makefile	f
+lib/glob/ChangeLog	f
+lib/glob/Makefile	f
+lib/glob/fnmatch.c	f
+lib/glob/fnmatch.h	f
+lib/glob/glob.c		f
+lib/glob/doc/Makefile	f
+lib/glob/doc/glob.texi	f
+lib/glob/ndir.h		f
+lib/malloc/Makefile	f
+lib/malloc/alloca.c	f
+lib/malloc/getpagesize.h	f
+lib/malloc/i386-alloca.s	f
+lib/malloc/malloc.c	f
+lib/malloc/x386-alloca.s	f
+lib/malloc/xmalloc.c	f
+lib/malloclib/Makefile	f
+lib/malloclib/alloca.c	f
+lib/malloclib/i386-alloca.s	f
+lib/malloclib/calloc.c	f
+lib/malloclib/cfree.c	f
+lib/malloclib/x386-alloca.s	f
+lib/malloclib/morecore.c	f
+lib/malloclib/free.c	f
+lib/malloclib/getpagesize.h	f
+lib/malloclib/malloc.c	f
+lib/malloclib/malloc.h	f
+lib/malloclib/xmalloc.c	f
+lib/malloclib/mcheck.c	f
+lib/malloclib/memalign.c	f
+lib/malloclib/mstats.c	f
+lib/malloclib/mtrace.awk	f
+lib/malloclib/mtrace.c	f
+lib/malloclib/realloc.c	f
+lib/malloclib/valloc.c	f
+lib/posixheaders/posixstat.h	f
+lib/posixheaders/ansi_stdlib.h	f
+lib/posixheaders/stdc.h	f
+lib/posixheaders/memalloc.h	f
+lib/posixheaders/filecntl.h	f
+lib/readline/COPYING	f
+lib/readline/readline.c	f
+lib/readline/readline.h	f
+lib/readline/ChangeLog	f
+lib/readline/vi_mode.c	f
+lib/readline/history.h	f
+lib/readline/Makefile	f
+lib/readline/chardefs.h	f
+lib/readline/emacs_keymap.c	f
+lib/readline/keymaps.h	f
+lib/readline/vi_keymap.c	f
+lib/readline/history.c	f
+lib/readline/funmap.c	f
+lib/readline/keymaps.c	f
+lib/readline/xmalloc.c	f
+lib/readline/doc/Makefile	f
+lib/readline/doc/rlman.texinfo	f
+lib/readline/doc/rltech.texinfo	f
+lib/readline/doc/rluser.texinfo	f
+lib/readline/doc/hist.texinfo	f
+lib/readline/doc/hstech.texinfo	f
+lib/readline/doc/hsuser.texinfo	f
+lib/readline/examples/Makefile	f
+lib/readline/examples/fileman.c	f
+lib/readline/examples/manexamp.c	f
+lib/readline/examples/histexamp.c	f
+lib/readline/examples/Inputrc	f
+lib/readline/README	f
+lib/readline/STANDALONE f
+lib/readline/search.c	f
+lib/readline/isearch.c	f
+lib/readline/rldefs.h	f
+lib/readline/rlconf.h	f
+lib/readline/parens.c	f
+lib/readline/rltty.c	f
+lib/readline/complete.c	f
+lib/readline/bind.c	f
+lib/readline/display.c	f
+lib/readline/signals.c	f
+lib/readline/doc/texindex.c	f
+lib/readline/tilde.c	f
+lib/readline/tilde.h	f
+lib/readline/posixstat.h	f
+lib/readline/ansi_stdlib.h	f
+lib/readline/memalloc.h	f
+lib/termcap/Makefile	f
+lib/termcap/termcap.c	f
+lib/termcap/termcap.h	f
+lib/termcap/tparam.c	f
+lib/termcap/version.c	f
+lib/termcap/grot/termcap.info	f
+lib/termcap/grot/termcap.info-1	f
+lib/termcap/grot/termcap.info-2	f
+lib/termcap/grot/termcap.info-3	f
+lib/termcap/grot/termcap.info-4	f
+lib/termcap/grot/NEWS	f
+lib/termcap/grot/INSTALL	f
+lib/termcap/grot/ChangeLog	f
+lib/termcap/grot/texinfo.tex	f
+lib/termcap/grot/termcap.texi	f
+lib/termcap/grot/Makefile.in	f
+lib/termcap/grot/configure	f
+lib/termcap/grot/configure.in	f
+lib/termcap/grot/COPYING	f
+lib/termcap/grot/README	f
+lib/tilde/ChangeLog	f
+lib/tilde/Makefile	f
+lib/tilde/doc/tilde.texi	f
+lib/tilde/doc/Makefile	f
+lib/tilde/tilde.c	f
+lib/tilde/tilde.h	f
+lib/tilde/memalloc.h	f
+CWRU/misc/open-files.c	f
+CWRU/misc/sigs.c	f
+CWRU/misc/pid.c		f
+CWRU/misc/sigstat.c	f
+CWRU/misc/bison		f
+CWRU/misc/aux-mach-desc	f
+CWRU/PLATFORMS		f
+CWRU/README		f
+CWRU/POSIX.NOTES	f
+CWRU/changelog		f
+CWRU/sh-redirection-hack f
+documentation/Makefile	f
+documentation/bash.1	f
+documentation/bash.ps	f
+documentation/bash.txt	f
+documentation/README	f
+documentation/readline.3	f
+documentation/readline.ps	f
+documentation/readline.txt	f
+documentation/texinfo.tex	f
+documentation/features.texi	f
+documentation/features.info	f
+documentation/features.dvi	f
+documentation/features.ps	f
+documentation/builtins.1	f
+documentation/builtins.ps	f
+documentation/builtins.txt	f
+documentation/article.ms	f
+documentation/article.ps	f
+documentation/article.txt	f
+support/cat-s		f
+support/mksysdefs	f
+support/printenv	f
+support/getcppsyms.c	f
+support/cppmagic	f
+support/bash.xbm	f
+support/FAQ		f
+support/PORTING		f
+support/mklinks		f
+support/mkdirs		f
+support/clone-bash	f
+support/bashbug.sh	f
+support/mkmachtype	f
+support/recho.c		f
+support/srcdir		f
+support/SYMLINKS	f
+support/fixlinks	f
+examples/functions/substr	f
+examples/functions/kshenv	f
+examples/functions/autoload	f
+examples/functions/csh-compat	f
+examples/functions/shcat	f
+examples/functions/substr2	f
+examples/functions/term		f
+examples/functions/whatis	f
+examples/functions/whence	f
+examples/functions/func		f
+examples/functions/dirname	f
+examples/functions/dirfuncs	f
+examples/functions/basename	f
+examples/functions/exitstat	f
+examples/functions/external	f
+examples/functions/fact		f
+examples/functions/manpage	f
+examples/functions/fstty	f
+examples/functions/jj.bash	f
+examples/functions/notify.bash	f
+examples/scripts/shprompt	f
+examples/scripts/adventure.sh	f
+examples/scripts/precedence	f
+examples/scripts/bcsh.sh	f
+examples/startup-files/Bashrc	f
+examples/startup-files/Bash_aliases	f
+examples/startup-files/Bash_profile	f
+examples/startup-files/bash-profile	f
+examples/startup-files/bashrc	f
+examples/suncmd.termcap	f
+examples/alias-conv.sh	f
+tests/README		f
+tests/dollar-at.sh	f
+tests/dollar-star.sh	f
+tests/dollar.right	f
+tests/exp-tests		f
+tests/exp.right		f
+tests/glob-test		f
+tests/glob.right	f
+tests/ifs-test-1.sh	f
+tests/ifs-test-2.sh	f
+tests/ifs-test-3.sh	f
+tests/ifs.1.right	f
+tests/ifs.2.right	f
+tests/ifs.3.right	f
+tests/input-line.sh	f
+tests/input-line.sub	f
+tests/input.right	f
+tests/minus-e		f
+tests/minus-e.right	f
+tests/new-exp.tests	f
+tests/new-exp.right	f
+tests/prec.right	f
+tests/precedence	f
+tests/run-all		f
+tests/run-dollars	f
+tests/run-exp-tests	f
+tests/run-glob-test	f
+tests/run-ifs-tests	f
+tests/run-input-test	f
+tests/run-minus-e	f
+tests/run-new-exp	f
+tests/run-precedence	f
+tests/run-set-e-test	f
+tests/run-strip		f
+tests/run-varenv	f
+tests/set-e-test	f
+tests/set-e.right	f
+tests/strip.tests	f
+tests/strip.right	f
+tests/tilde-tests	f
+tests/tilde.right	f
+tests/varenv.right	f
+tests/varenv.sh		f
+tests/misc/chld-trap.sh	f
+tests/misc/dot-test-1.sh	f
+tests/misc/dot-test-1.sub	f
+tests/misc/gotest		f
+tests/misc/perf-script		f
+tests/misc/redir.t1.sh		f
+tests/misc/redir.t2.sh		f
+tests/misc/redir.t3.sh		f
+tests/misc/redir.t3.sub		f
+tests/misc/redir.t4.sh		f
+tests/misc/run.r1.sh	f
+tests/misc/run.r2.sh	f
+tests/misc/run.r3.sh	f
+tests/misc/sigint.t1.sh		f
+tests/misc/sigint.t2.sh		f
+tests/misc/sigint.t3.sh		f
+tests/misc/sigint.t4.sh		f
+tests/misc/test-minus-e.1	f
+tests/misc/test-minus-e.2	f
+portbash/signals.sh	f
+portbash/stdio.sh	f
+portbash/libc.sh	f
+portbash/mkdesc.sh	f
+portbash/README		f
+portbash/strings.sh	f
+portbash/syscalls.sh	f
+portbash/pgrp.c		f

Makefile

@@ -0,0 +1,115 @@
+# Hey Emacs, this Makefile is in -*- makefile -*- mode!
+#
+# Makefile for Bash.
+# If your cpp doesn't like -P, just get rid of it (the -P, not cpp).
+# If you wish to use Gcc, then type `make CC=gcc CPPNAME='$(CC) -E''.
+# If you wish to use GNU's Make, then change `MAKE'.
+# If you don't like the destination, then change `bindir'.
+# The file that you most likely want to look at is cpp-Makefile.
+#
+# If you haven't read README, now might be a good time.
+
+# Include some boilerplate Gnu makefile definitions.
+prefix = /usr/local
+exec_prefix = $(prefix)
+bindir = $(exec_prefix)/bin
+srcdir = .
+VPATH = $(srcdir)
+
+# MAKE    = make
+RM      = rm -f
+SHELL   = /bin/sh
+GAWK     = awk
+# GAWK     = gawk
+
+# Force CPPNAME to be the name of your C preprocesor if Bash can't
+# find it.  For instance, `CPPNAME=/usr/libexec/cpp' on 4.4 BSD.
+# If all else fails, set CPPNAME=$(CC) -E
+CPPNAME =
+CPP     = `$(SHELL) $(CPPMAGIC) $(GETCPPSYMS) "$(CPPNAME)"` -P
+
+CPP_MAKEFILE = $(srcdir)/cpp-Makefile
+ANSI_MAKEFILE = ansi-Makefile
+
+# CPPFLAGS = $(SYSTEM) $(CPP_DEFINES)
+CPPFLAGS = $(CPP_DEFINES) -I. -I$(srcdir)
+CPP_ARGS = -DCPP_CC="$(CC)"
+
+SUPPORTDIR     = ./support/
+SUPPORTSRC     = $(srcdir)/support/
+
+MKSYSDEFS      = $(SUPPORTSRC)mksysdefs
+CPPMAGIC       = $(SUPPORTSRC)cppmagic
+CAT_S          = $(SUPPORTSRC)cat-s
+GETCPPSYMS     = $(SUPPORTDIR)getcppsyms
+GETCPPSYMS_SRC = $(SUPPORTSRC)getcppsyms.c
+
+# Here is a command which compresses runs of multiple blank lines to a
+# single blank line.  "cat -s" works for BSD systems, but not for USG
+# systems.  You can use an awk script if you like.  If you have too
+# much trouble with this, just forget it.  It is for making
+# bash-Makefile pretty and readable; something that isn't strictly
+# necessary.
+# SQUASH_BLANKS = cat -s
+#
+SQUASH_BLANKS = $(GAWK) -f $(CAT_S)
+
+all:	.notified bash-Makefile
+	$(MAKE) -f bash-Makefile $(MFLAGS) $(MAKEARGS) srcdir=$(srcdir)
+
+bash-Makefile: $(CPP_MAKEFILE) Makefile machines.h sysdefs.h config.h
+	@-if [ -f ansi-Makefile ]; then \
+	    echo "cp ansi-Makefile tmp-Makefile.c"; \
+	    cp ansi-Makefile tmp-Makefile.c; else \
+	    echo "cp $(CPP_MAKEFILE) tmp-Makefile.c"; \
+	    cp $(CPP_MAKEFILE) tmp-Makefile.c; \
+	  fi
+	$(RM) $(GETCPPSYMS)
+	$(SHELL) $(SUPPORTSRC)mkdirs support
+	$(CC) -o $(GETCPPSYMS) $(GETCPPSYMS_SRC)
+	rm -f bash-Makefile
+	@$(SHELL) -c 'echo $(CPP) $(CPPFLAGS) $(CPP_ARGS) tmp-Makefile.c \| $(SQUASH_BLANKS) \> bash-Makefile'
+	@$(SHELL) -c '$(CPP) $(CPPFLAGS) $(CPP_ARGS) tmp-Makefile.c | $(SQUASH_BLANKS) >bash-Makefile'
+	rm -f tmp-Makefile.c
+	@test -s bash-Makefile || { rm -f bash-Makefile ; exit 1; }
+
+sysdefs.h: $(MKSYSDEFS)
+	$(SHELL) $(MKSYSDEFS) -s $(srcdir)
+
+# This is also performed by support/mksysdefs, but there's no way to change
+# it if cpp-Makefile is changed without changing anything else, since there
+# are no dependencies.  This lets you run `make ansi-Makefile'.
+ansi-Makefile: $(CPP_MAKEFILE)
+	grep -v '/\*\*/' $(CPP_MAKEFILE) > $@
+
+# Subsequent lines contain targets that are correctly handled by an
+# existing bash-Makefile.
+
+install uninstall newversion architecture: bash-Makefile
+	$(MAKE) -f bash-Makefile $(MFLAGS) $(MAKEARGS) bindir=$(bindir) \
+		prefix=$(prefix) $@
+
+tests DEFINES tags documentation: bash-Makefile directory-frob
+	$(MAKE) -f bash-Makefile $(MFLAGS) $(MAKEARGS) $@
+
+clean distclean realclean mostlyclean maintainer-clean: bash-Makefile directory-frob
+	rm -f .notified
+	$(MAKE) -f bash-Makefile $(MFLAGS) $(MAKEARGS) $@
+
+directory-frob:
+
+.NOEXPORT:
+
+.notified:
+	@echo ""
+	@echo "   You are about to make this version of GNU Bash for"
+	@echo "   this architecture for the first time.  If you haven't"
+	@echo "   yet read the README file, you may want to do so.  If"
+	@echo "   you wish to report a bug in Bash, or in the installation"
+	@echo "   procedure, please run the bashbug script and include:"
+	@echo ""
+	@echo "	* a description of the bug,"
+	@echo "	* a recipe for recreating the bug reliably,"
+	@echo "	* a fix for the bug if you have one!"
+	@echo ""
+	@touch .notified

NEWS

@@ -0,0 +1,10 @@
+This file documents the bugs fixed between this release, bash-1.14.7,
+and the last public bash release, 1.14.6.
+
+1.  Bugs fixed in Bash
+
+a.  A memory leak that caused long-running scripts to eventually consume
+    all available memory was fixed.
+
+b.  A sign-extension bug that caused a security hole for non-interactive
+    shells was fixed.

README

@@ -0,0 +1,52 @@
+This README file is in -*- text -*- mode, because Emacs likes it that way.
+
+This is GNU Bash, version 1.14.  Bash is the GNU Project's Bourne
+Again SHell, an interactive shell with Bourne shell syntax (/bin/sh);
+but also with interactive command line editing, job control on
+architectures that support it, Csh-like history features and brace
+expansion, and a slew of other stuff.  For more information on the
+features of Bash that are new to this type of shell, see the file
+`documentation/features.texi'.  There is also a DVI file there, as
+well as a large man page.
+
+To compile it, try typing `make'.  Bash auto-configures the build
+process, so no intervention should be necessary.  If you want to
+use gcc, type `make CC=gcc CPPNAME='$(CC) -E''.
+
+You may want to read the file INSTALL in this directory for more
+information if the make fails.
+
+If you are a csh user and wish to convert your csh aliases to Bash
+aliases, you may wish to use the script in examples/alias-conv.sh
+as a starting point.
+
+Bug reports for 1.14 should be sent to:
+
+	bug-bash@prep.ai.mit.edu
+
+using the `bashbug' program that is built and installed at the same
+time as bash.
+
+The discussion list "bug-bash@prep.ai.mit.edu" often contains information
+about new ports of Bash, or discussions of new features or behavior
+changes that people would like.  This mailing list is also available
+as a usenet newsgroup: gnu.bash.bug.
+
+When you send a bug report to bash-maintainers@prep.ai.mit.edu, please
+include:
+
+	* the version number of Bash
+	* the machine and OS that it is running on (see .machine or .made)
+	* a description of the bug
+	* a recipe for recreating the bug reliably
+	* a fix for the bug if you have one!
+
+The `bashbug' program includes much of this automatically.
+
+While the Bash maintainers do not promise to fix all bugs, we would
+like this shell to be the best that we can make it.
+
+Enjoy!
+
+Chet Ramey
+chet@po.cwru.edu

RELEASE

@@ -0,0 +1,269 @@
+This file details the changes between the previous release of bash (1.13.5)
+and this release (1.14.0).
+
+1. New Features in Bash
+
+a.  The source has been reorganized:  nearly all extern function
+    declarations have been moved to header files, function prototypes
+    have been added to most header files, function declarations have
+    been moved to file scope, dead code has been removed, the
+    bash history code has been isolated in bashhist.[ch], and several
+    new header files have been created
+
+b.  `set -o posix' puts bash into Posix.2 mode
+
+c.  If $POSIX_PEDANTIC exists in the initial environment or is assigned
+    a value, bash enters Posix.2 mode
+
+d.  Bash sets $OSTYPE to a string describing the UNIX version
+
+e.  The features.info file was completely rewritten and now reflects
+    the current state of things
+
+f.  A manual page for readline is in documentation/readline.{3,ps}
+
+g.  The test builtin emulates /dev/fd/x for systems without /dev/fd
+
+h.  `dirs' has -n and +n options to access members of the directory stack
+
+i.  Prompt string expansion handles invisible characters in the prompt;
+    \[ and \] are used (and required) to start and end sequences of
+    invisible chars
+
+j.  NO_PROMPT_VARS has been removed
+
+k.  New machine descriptions have been added:  IBM AIX/ESA, NEC EWS, NetBSD,
+    FreeBSD, QNX 4.2, concurrent, MIPS SVR4.2, Lynx 2.1
+
+l.  RESTRICTED_SHELL is no longer defined by default in config.h
+
+m.  The version string in $BASH_VERSION has changed to dist.patch(build)
+
+n.  $history_control has been renamed to $HISTCONTROL and now takes the
+    value `ignoreboth' ($history_control is still accepted for backwards
+    compatibility)
+
+o.  There is a new program `bashbug' for reporting bugs.  Eventually I will
+    probably switch to gnats.
+
+p.  auto_resume can take the values `exact' and `substring'
+
+q.  `set -P' (`set -o physical') enables the same physical view of the
+    file system that `nolinks' enables (`nolinks' will remain for one
+    more release)
+
+r.  There is a `mkmachtype' program to generate a GNU-style machine type
+    string (e.g., `sparc-sun-sunos4.1.2') suitable for assigning to
+    $MACHTYPE
+
+s.  The variable $HISTCMD returns the current history number
+
+t.  Variables in directory names are now expanded while doing completion
+
+u.  The test suite has been expanded and is runnable as a regression test
+    with `make tests'
+
+v.  `bye' is no longer a builtin synonym for `exit'
+
+w.  The ksh `select' control construct has been implemented
+
+x.  The `ignoreeof' attribute can be inherited if $IGNOREEOF is exported
+
+y.  The `USG-style' echo is now a configuration option.  Define
+    DEFAULT_ECHO_TO_USG for default \-interpretation without the -e flag
+
+z.  There is a copy of an article I wrote about bash for the Linux
+    Journal in documentation/article.{ms,ps}
+
+aa. The `pwd' builtin now obeys the setting of `set -o physical' (`nolinks')
+
+bb. Process substitution is no longer performed when the shell is in
+    `posix mode'
+
+cc. Users may change the debugging and optimization flags to cc by specifying
+    CFLAGS to make
+
+2. New Features in Readline
+
+a.  Readline now understands sequences of invisible characters in the prompt
+    string, as long as they are escaped (e.g., by the bash \[ and \] escapes)
+
+b.  A `set keymap' variable assignment
+
+c.  A `bell-style' variable that can be set to `visible', `audio', or `none'
+
+d.  A `show-all-if-ambiguous' variable, which causes non-unique completion
+    to immediately list the possible completions
+
+e.  An `output-meta' variable to make readline directly output chars
+    with the eighth bit set
+
+f.  New bindable readline commands: kill-whole-line, tilde-expand,
+    vi-redo, vi-tilde-expand, emacs-editing-mode,
+    non-incremental-forward-search-history-again,
+    non-incremental-reverse-search-history-again
+
+g.  New history-search-forward and history-search-backward to search for
+    the characters between the start of the current line and point
+
+h.  Readline takes the name of the startup file from the INPUTRC variable
+    before defaulting to ~/.inputrc
+
+i.  isearch no longer finds identical lines multiple times in succession
+
+j.  M-C-H bound to backward-kill-word in emacs mode
+
+k.  M-~ bound to tilde-expand in emacs mode
+
+l.  History expansion is now fully csh-compatible: missing modifiers and
+    substitutions have been added, and bugs fixed
+
+m.  When asking whether or not to display the possible completions, readline
+    now accepts space as equivalent to `y' and rubout for `n'
+
+n.  Readline now attempts to find and bind the arrow keys into the vi mode
+    movement keymap
+
+3.  Bugs fixed in Bash
+
+a.  Portability fixes: `index' and `rindex' are gone completely, many
+    OS-specific defines have been replaced with feature-test macros,
+    the use of alloca has been reduced, and other platform-specific fixes
+    (e.g. cray) have been made
+
+b.  The man page has been fixed up and brought up to date
+
+c.  Speed improvements: here documents, variable expansion, history
+    expansion, command substitution
+
+d.  If history is stifled, the history list replaces the history file at
+    exit
+
+e.  Asynchronous jobs re-run with fc -s now print the job number
+
+f.  Output redirections do not perform filename expansion in Posix.2 mode
+    when the shell is not interactive
+
+g.  operate_and_get_next now works on the most recent line even if the
+    history is unstifled
+
+h.  $PROMPT_COMMAND execution no longer causes recursive invocations
+    of yyparse()
+
+i.  An error message is printed if job control initialization fails
+
+j.  A command found in $PATH from the temporary environment is not hashed
+
+k.  Errors display the name of the script if the shell is not interactive
+
+l.  Fixed expression evaluation so blank expressions return 0
+
+m.  Fixed a bug that caused SIGINT and SIGQUIT not to be ignored in some
+    asynchronous children
+
+n.  Pipes used for /dev/fd process substitution are now closed on errors
+
+o.  Fixed /dev/null redirection so that ( list ) subshells inherit the
+    `stdin-has-been-redirected' flag as in sh
+
+p.  Process substitution now works only when unquoted
+
+q.  Fixed a bug where the async flag was added inappropriately in a command
+    like `a;b;c;d &'
+
+r.  Fixed off-by-one bug which caused negative history offsets in `fc' to
+    be wrong
+
+s.  Shell now remembers mail dates at startup on all systems
+
+t.  Posix systems without job control no longer create so many zombies
+
+u.  $ENV is now sourced by shells forked to execute scripts without a
+    leading `#!' line
+
+v.  Non-root users can now use the `unlimited' argument to ulimit and have
+    the resource value set to the hard limit
+
+w.  Made bash more sh-compatible by assigning the first argument after
+    `-c command' to $0
+
+x.  Fixed mail checking bug to note that *new* mail has arrived
+
+y.  Fixed off-by-one error in mailcheck.c:free_mail_files()
+
+z.  Fixed a bug where command strings passed to `bash -c' would be truncated
+    after executing the first disk command in the string
+
+aa. Fixed a bug which caused redirections passed to executable commands with
+    input or output pipes to be closed before the command was executed
+
+bb. Fixed a bug which caused bash to search for files supplied on the command
+    line in the $PATH if the initial open failed, even if the names contained
+    a slash
+
+cc. The initial argument parsing was fixed up so that other options can
+    be supplied with -c (that is, `sh -ec command' now works as make
+    intends), and so `bash -o' lists all the shell options at startup.
+
+dd. Error messages are consistently prefixed with the name of the shell
+    or shell script when non-interactive.
+
+ee. Fixed up a problem with the `read' builtin that occurred when more
+    variables than arguments were supplied.
+
+ff. Unset the variables passed to `read' as arguments when EOF is
+    read from stdin (sh, Posix.2 compatibility).
+
+gg. Fixes to the command printing code to make the output of `type'
+    available as legal shell input.
+
+ii. Fixes so that command completion is attempted after all of the shell
+    command separator characters.
+
+jj. Fixes to the shell completion code so that it handles quoted characters
+    and substrings better.
+
+kk. Bash no longer looks through $PATH for a shell script passed as an
+    argument if the name contains slashes.
+
+ll. Bash now checks that the `name' in a `name[=value]' argument to `declare'
+    (and thus `typeset', `export', and `readonly') is a legal shell variable
+    name.
+
+4.  Bugs fixed in Readline
+
+a.  The ^W and ^U bindings in non-incremental search mode have been changed
+    to be closer to what Posix specifies
+
+b.  Tries to initialize the keypad to enable the arrow keys
+
+c.  Multiple words are now killed and yanked in the right order
+
+d.  rl_read_init_file now reads filenames in a more regular order:  the last
+    one read, $INPUTRC, then ~/.inputrc
+
+e.  yank_nth_arg inserts a space in the right place in vi mode
+
+f.  Fixed a bug in the history library that tried to write to a file opened
+    O_RDONLY
+
+g.  Binding of `0' in vi command mode is now right
+
+h.  The VISIBLE_STATS completion listing code now follows symlinks
+
+i.  Memory allocated with alloca() is no longer passed to other functions
+
+j.  Error messages are now printed for unrecognized history modifiers
+
+k.  Fixed a problem with history library and `!#'; now it is more csh-like.
+
+l.  Fixed a csh incompatibility in the history library: now only an end of
+    line or `?' terminates a ?string history search string.
+
+m.  Fixed a problem with readline completion that sometimes caused possible
+    matches to be listed one per line when `show-all-if-ambiguous' was set.
+
+n.  Fixed a problem in the readline display code that caused divide-by-zero
+    errors.
+
+o.  Fixed an off-by-one error in the kill ring reallocation code.

alias.c

@@ -0,0 +1,535 @@
+/* alias.c -- Not a full alias, but just the kind that we use in the
+   shell.  Csh style alias is somewhere else (`over there, in a box'). */
+
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <stdio.h>
+#include "bashansi.h"
+#include "config.h"
+#include "command.h"
+#include "general.h"
+#include "hash.h"
+#include "alias.h"
+
+static int qsort_alias_compare ();
+
+/* Non-zero means expand all words on the line.  Otherwise, expand
+   after first expansion if the expansion ends in a space. */
+int alias_expand_all = 0;
+
+/* The list of aliases that we have. */
+HASH_TABLE *aliases = (HASH_TABLE *)NULL;
+
+void
+initialize_aliases ()
+{
+  if (!aliases)
+    aliases = make_hash_table (0);
+}
+
+/* Scan the list of aliases looking for one with NAME.  Return NULL
+   if the alias doesn't exist, else a pointer to the assoc. */
+ASSOC *
+find_alias (name)
+     char *name;
+{
+  BUCKET_CONTENTS *al;
+
+  if (!aliases)
+    return ((ASSOC *)NULL);
+  else
+    al = find_hash_item (name, aliases);
+
+  if (al)
+    return ((ASSOC *)al->data);
+  else
+    return ((ASSOC *)NULL);
+}
+
+/* Return the value of the alias for NAME, or NULL if there is none. */
+char *
+get_alias_value (name)
+     char *name;
+{
+  ASSOC *alias = find_alias (name);
+  if (alias)
+    return (alias->value);
+  else
+    return ((char *)NULL);
+}
+
+/* Make a new alias from NAME and VALUE.  If NAME can be found,
+   then replace its value. */
+void
+add_alias (name, value)
+     char *name, *value;
+{
+  ASSOC *temp = (ASSOC *)NULL;
+
+  if (!aliases)
+    initialize_aliases ();
+  else
+    temp = find_alias (name);
+
+  if (temp)
+    {
+      free (temp->value);
+      temp->value = savestring (value);
+    }
+  else
+    {
+      BUCKET_CONTENTS *elt;
+
+      temp = (ASSOC *)xmalloc (sizeof (ASSOC));
+      temp->name = savestring (name);
+      temp->value = savestring (value);
+
+      elt = add_hash_item (savestring (name), aliases);
+      elt->data = (char *)temp;
+    }
+}
+
+/* Remove the alias with name NAME from the alias table.  Returns
+   the number of aliases left in the table, or -1 if the alias didn't
+   exist. */
+int
+remove_alias (name)
+     char *name;
+{
+  BUCKET_CONTENTS *elt;
+
+  if (!aliases)
+    return (-1);
+
+  elt = remove_hash_item (name, aliases);
+  if (elt)
+    {
+      ASSOC *t;
+
+      t = (ASSOC *)elt->data;
+      free (t->name);
+      free (t->value);
+      free (elt->key);		/* alias name */
+      free (t);
+
+      return (aliases->nentries);
+    }
+  return (-1);
+}
+
+/* Delete a hash bucket chain of aliases. */
+static void
+delete_alias_list (alias_list)
+     BUCKET_CONTENTS *alias_list;
+{
+  register BUCKET_CONTENTS *bp, *temp;
+  register ASSOC *a;
+
+  for (bp = alias_list; bp; )
+    {
+      temp = bp->next;
+      a = (ASSOC *)bp->data;
+      free (a->value);
+      free (a->name);
+      free (bp->data);
+      free (bp->key);
+      free (bp);
+      bp = temp;
+    }
+}
+
+/* Delete all aliases. */
+void
+delete_all_aliases ()
+{
+  register int i;
+
+  if (!aliases)
+    return;
+
+  for (i = 0; i < aliases->nbuckets; i++)
+    {
+      register BUCKET_CONTENTS *bp;
+
+      bp = get_hash_bucket (i, aliases);
+      delete_alias_list (bp);
+    }
+  free (aliases);
+  aliases = (HASH_TABLE *)NULL;
+}
+
+/* Return an array of aliases that satisfy the conditions tested by FUNCTION.
+   If FUNCTION is NULL, return all aliases. */
+static ASSOC **
+map_over_aliases (function)
+     Function *function;
+{
+  register int i;
+  register BUCKET_CONTENTS *tlist;
+  ASSOC *alias, **list = (ASSOC **)NULL;
+  int list_index = 0, list_size = 0;
+
+  for (i = 0; i < aliases->nbuckets; i++)
+    {
+      tlist = get_hash_bucket (i, aliases);
+
+      while (tlist)
+	{
+	  alias = (ASSOC *)tlist->data;
+
+	  if (!function || (*function) (alias))
+	    {
+	      if (list_index + 1 >= list_size)
+		list = (ASSOC **)
+		  xrealloc ((char *)list, (list_size += 20) * sizeof (ASSOC *));
+
+	      list[list_index++] = alias;
+	      list[list_index] = (ASSOC *)NULL;
+	    }
+	  tlist = tlist->next;
+	}
+    }
+  return (list);
+}
+
+static void
+sort_aliases (array)
+     ASSOC **array;
+{
+  qsort (array, array_len ((char **)array), sizeof (ASSOC *), qsort_alias_compare);
+}
+
+static int
+qsort_alias_compare (as1, as2)
+     ASSOC **as1, **as2;
+{
+  int result;
+  
+  if ((result = (*as1)->name[0] - (*as2)->name[0]) == 0)
+    result = strcmp ((*as1)->name, (*as2)->name);
+
+  return (result);
+}
+        
+/* Return a sorted list of all defined aliases */     
+ASSOC **
+all_aliases ()
+{
+  ASSOC **list;
+
+  if (!aliases)
+    return ((ASSOC **)NULL);
+
+  list = map_over_aliases ((Function *)NULL);
+  if (list)
+    sort_aliases (list);
+  return (list);
+}
+
+char *
+alias_expand_word (s)
+     char *s;
+{
+  ASSOC *r = find_alias (s);
+
+  if (r)
+    return (savestring (r->value));
+  else
+    return ((char *)NULL);
+}
+
+/* Return non-zero if CHARACTER is a member of the class of characters
+   that are self-delimiting in the shell (this really means that these
+   characters delimit tokens). */
+#define self_delimiting(character) (member ((character), " \t\n\r;|&()"))
+
+/* Return non-zero if CHARACTER is a member of the class of characters
+   that delimit commands in the shell. */
+#define command_separator(character) (member ((character), "\r\n;|&("))
+
+/* If this is 1, we are checking the next token read for alias expansion
+   because it is the first word in a command. */
+static int command_word;
+
+/* This is for skipping quoted strings in alias expansions. */
+#define quote_char(c)  (((c) == '\'') || ((c) == '"'))
+
+/* Consume a quoted string from STRING, starting at string[START] (so
+   string[START] is the opening quote character), and return the index
+   of the closing quote character matching the opening quote character.
+   This handles single matching pairs of unquoted quotes; it could afford
+   to be a little smarter... This skips words between balanced pairs of
+   quotes, words where the first character is quoted with a `\', and other
+   backslash-escaped characters. */
+
+static int
+skipquotes (string, start)
+     char *string;
+     int start;
+{
+  register int i;
+  int delimiter = string[start];
+
+  /* i starts at START + 1 because string[START] is the opening quote
+     character. */
+  for (i = start + 1 ; string[i] ; i++)
+    {
+      if (string[i] == '\\')
+	{
+	  i++;		/* skip backslash-quoted quote characters, too */
+	  continue;
+	}
+
+      if (string[i] == delimiter)
+	return i;
+    }
+  return (i);
+}
+
+/* Skip the white space and any quoted characters in STRING, starting at
+   START.  Return the new index into STRING, after zero or more characters
+   have been skipped. */
+static int
+skipws (string, start)
+     char *string;
+     int start;
+{
+  register int i = 0;
+  int pass_next, backslash_quoted_word, peekc;
+
+  /* skip quoted strings, in ' or ", and words in which a character is quoted
+     with a `\'. */
+  backslash_quoted_word = pass_next = 0;
+
+  /* Skip leading whitespace (or separator characters), and quoted words.
+     But save it in the output.  */
+
+  for (i = start; string[i]; i++)
+    {
+      if (pass_next)
+	{
+	  pass_next = 0;
+	  continue;
+	}
+
+      if (whitespace (string[i]))
+	{
+	  backslash_quoted_word = 0; /* we are no longer in a backslash-quoted word */
+	  continue;
+	}
+
+      if (string[i] == '\\')
+	{
+	  peekc = string[i+1];
+	  if (isletter (peekc))
+	    backslash_quoted_word++;	/* this is a backslash-quoted word */
+	  else
+	    pass_next++;
+	  continue;
+	}
+
+      /* This only handles single pairs of non-escaped quotes.  This
+	 overloads backslash_quoted_word to also mean that a word like
+	 ""f is being scanned, so that the quotes will inhibit any expansion
+	 of the word. */
+      if (quote_char(string[i]))
+	{
+	  i = skipquotes (string, i);
+	  /* This could be a line that contains a single quote character,
+	     in which case skipquotes () terminates with string[i] == '\0'
+	     (the end of the string).  Check for that here. */
+	  if (string[i] == '\0')
+	    break;
+
+	  peekc = string[i + 1];
+	  if (isletter (peekc))
+	    backslash_quoted_word++;
+	  continue;
+	}
+
+      /* If we're in the middle of some kind of quoted word, let it
+	 pass through. */
+      if (backslash_quoted_word)
+	continue;
+
+      /* If this character is a shell command separator, then set a hint for
+	 alias_expand that the next token is the first word in a command. */
+
+      if (command_separator (string[i]))
+	{
+	  command_word++;
+	  continue;
+	}
+      break;
+    }
+  return (i);
+}
+
+/* Characters that may appear in a token.  Basically, anything except white
+   space and a token separator. */
+#define token_char(c)	(!((whitespace (string[i]) || self_delimiting (string[i]))))
+
+/* Read from START in STRING until the next separator character, and return
+   the index of that separator.  Skip backslash-quoted characters.  Call
+   skipquotes () for quoted strings in the middle or at the end of tokens,
+   so all characters show up (e.g. foo'' and foo""bar) */
+static int
+rd_token (string, start)
+     char *string; 
+     int start;
+{
+  register int i;
+
+  /* From here to next separator character is a token. */
+  for (i = start; string[i] && token_char (string[i]); i++)
+    {
+      if (string[i] == '\\')
+	{
+	  i++;	/* skip backslash-escaped character */
+	  continue;
+	}
+
+      /* If this character is a quote character, we want to call skipquotes
+	 to get the whole quoted portion as part of this word.  That word
+	 will not generally match an alias, even if te unquoted word would
+	 have.  The presence of the quotes in the token serves then to 
+	 inhibit expansion. */
+      if (quote_char (string[i]))
+	{
+	  i = skipquotes (string, i);
+	  /* Now string[i] is the matching quote character, and the
+	     quoted portion of the token has been scanned. */
+	  continue;
+	}
+    }
+  return (i);
+}
+
+/* Return a new line, with any aliases substituted. */
+char *
+alias_expand (string)
+     char *string;
+{
+  int line_len = 1 + strlen (string);
+  char *line = (char *)xmalloc (line_len);
+  register int i, j, start;
+  char *token = xmalloc (line_len);
+  int tl, real_start, expand_next, expand_this_token;
+  ASSOC *alias;
+
+  line[0] = i = 0;
+  expand_next = 0;
+  command_word = 1; /* initialized to expand the first word on the line */
+
+  /* Each time through the loop we find the next word in line.  If it
+     has an alias, substitute
+     the alias value.  If the value ends in ` ', then try again
+     with the next word.  Else, if there is no value, or if
+     the value does not end in space, we are done. */
+
+  for (;;)
+    {
+
+      token[0] = 0;
+      start = i;
+
+      /* Skip white space and quoted characters */
+      i = skipws (string, start);
+
+      if (start == i && string[i] == '\0')
+	{
+	  free (token);
+	  return (line);
+	}
+
+      /* copy the just-skipped characters into the output string,
+	 expanding it if there is not enough room. */
+      j = strlen (line);
+      tl = i - start;	/* number of characters just skipped */
+      if (1 + j + tl >= line_len)
+	line = (char *)xrealloc (line, line_len += (50 + tl));
+      strncpy (line + j, string + start, tl);
+      line[j + tl] = '\0';
+
+      real_start = i;
+
+      command_word = command_word || (command_separator (string[i]));
+      expand_this_token = (command_word || expand_next);
+      expand_next = 0;
+
+      /* Read the next token, and copy it into TOKEN. */
+      start = i;
+      i = rd_token (string, start);
+
+      tl = i - start;	/* token length */
+
+      /* If tl == 0, but we're not at the end of the string, then we have a
+	 single-character token, probably a delimiter */
+      if (tl == 0 && string[i] != '\0')
+	{
+	  tl = 1;
+	  i++;		/* move past it */
+	}
+
+      strncpy (token, string + start, tl);
+      token [tl] = '\0';
+
+      /* If there is a backslash-escaped character quoted in TOKEN,
+	 then we don't do alias expansion.  This should check for all
+	 other quoting characters, too. */
+      if (strchr (token, '\\'))
+	expand_this_token = 0;
+
+      /* If we should be expanding here, if we are expanding all words, or if
+	 we are in a location in the string where an expansion is supposed to
+	 take place, see if this word has a substitution.  If it does, then do
+	 the expansion.  Note that we defer the alias value lookup until we
+	 are sure we are expanding this token. */
+
+      if ((token[0]) &&
+	  (expand_this_token || alias_expand_all) &&
+	  (alias = find_alias (token)))
+	{
+	  char *v = alias->value;
+	  int l = strlen (v);
+      
+	  /* +3 because we possibly add one more character below. */
+	  if ((l + 3) > line_len - (int)strlen (line))
+	    line = (char *)xrealloc (line, line_len += (50 + l));
+
+	  strcat (line, v);
+
+	  if ((expand_this_token && l && whitespace (v[l - 1])) ||
+	      alias_expand_all)
+	    expand_next = 1;
+	}
+      else
+	{
+	  int ll = strlen (line);
+	  int tlen = i - real_start; /* tlen == strlen(token) */
+
+	  if (ll + tlen + 2 > line_len)
+	    line = (char *)xrealloc (line, line_len += 50 + ll + tlen);
+
+	  strncpy (line + ll, string + real_start, tlen);
+	  line[ll + tlen] = '\0';
+	}
+      command_word = 0;
+    }
+}

alias.h

@@ -0,0 +1,75 @@
+/* alias.h -- structure definitions. */
+
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (_ALIAS_)
+#define _ALIAS_
+
+#include "hash.h"
+
+extern char *xmalloc ();
+
+#if !defined (whitespace)
+#  define whitespace(c) (((c) == ' ') || ((c) == '\t'))
+#endif /* !whitespace */
+
+#if !defined (savestring)
+#  define savestring(x) (char *)strcpy (xmalloc (1 + strlen (x)), (x))
+#endif /* !savestring */
+
+#if !defined (NULL)
+#  if defined (__STDC__)
+#    define NULL ((void *) 0)
+#  else
+#    define NULL 0x0
+#  endif /* !__STDC__ */
+#endif /* !NULL */
+
+typedef struct {
+  char *name;
+  char *value;
+} ASSOC;
+
+/* The list of known aliases. */
+extern HASH_TABLE *aliases;
+
+extern void initialize_aliases ();
+
+/* Scan the list of aliases looking for one with NAME.  Return NULL
+   if the alias doesn't exist, else a pointer to the assoc. */
+extern ASSOC *find_alias ();
+
+/* Return the value of the alias for NAME, or NULL if there is none. */
+extern char *get_alias_value ();
+
+/* Make a new alias from NAME and VALUE.  If NAME can be found,
+   then replace its value. */
+extern void add_alias ();
+
+/* Remove the alias with name NAME from the alias list.  Returns
+   the index of the removed alias, or -1 if the alias didn't exist. */
+extern int remove_alias ();
+
+/* Return a new line, with any aliases expanded. */
+extern char *alias_expand ();
+
+/* Return an array of all defined aliases. */
+extern ASSOC **all_aliases ();
+
+#endif /* _ALIAS_ */

ansi_stdlib.h

@@ -0,0 +1,41 @@
+/* ansi_stdlib.h -- An ANSI Standard stdlib.h. */
+/* A minimal stdlib.h containing extern declarations for those functions
+   that bash uses. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (_STDLIB_H_)
+#define	_STDLIB_H_ 1
+
+/* String conversion functions. */
+extern int atoi ();
+extern long int atol ();
+
+/* Memory allocation functions. */
+extern char *malloc ();
+extern char *realloc ();
+extern void free ();
+
+/* Other miscellaneous functions. */
+extern void abort ();
+extern void exit ();
+extern char *getenv ();
+extern void qsort ();
+
+#endif /* _STDLIB_H  */

bashansi.h

@@ -0,0 +1,36 @@
+/* bashansi.h -- Typically included information required by picky compilers. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (_BASHANSI_H_)
+#define _BASHANSI_H_
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#if defined (HAVE_STDLIB_H)
+#  include <stdlib.h>
+#else
+#  include "ansi_stdlib.h"
+#endif /* !HAVE_STDLIB_H */
+
+#endif /* !_BASHANSI_H_ */

bashhist.c

@@ -0,0 +1,390 @@
+/* bashhist.c -- bash interface to the GNU history library. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <errno.h>
+#include "bashansi.h"
+#include "posixstat.h"
+#include "filecntl.h"
+#include "shell.h"
+#include "flags.h"
+#include <readline/history.h>
+
+/* Declarations of bash history variables. */
+/* Non-zero means to remember lines typed to the shell on the history
+   list.  This is different than the user-controlled behaviour; this
+   becomes zero when we read lines from a file, for example. */
+int remember_on_history = 1;
+
+/* The number of lines that Bash has added to this history session. */
+int history_lines_this_session = 0;
+
+/* The number of lines that Bash has read from the history file. */
+int history_lines_in_file = 0;
+
+/* Non-zero means do no history expansion on this line, regardless
+   of what history_expansion says. */
+int history_expansion_inhibited = 0;
+
+/* By default, every line is saved in the history individually.  I.e.,
+   if the user enters:
+	bash$ for i in a b c
+        > do
+        > echo $i
+        > done
+   Each line will be individually saved in the history.
+	bash$ history
+	10  for i in a b c
+        11  do
+        12  echo $i
+        13  done
+        14  history
+   If the variable command_oriented_history is set, multiple lines
+   which form one command will be saved as one history entry.
+	bash$ for i in a b c
+        > do
+        > echo $i
+        > done
+        bash$ history
+	10  for i in a b c
+    do
+    echo $i
+    done
+        11  history
+   The user can then recall the whole command all at once instead
+   of just being able to recall one line at a time.
+   */
+int command_oriented_history = 0;
+
+/* A nit for picking at history saving.
+   Value of 0 means save all lines parsed by the shell on the history.
+   Value of 1 means save all lines that do not start with a space.
+   Value of 2 means save all lines that do not match the last line saved. */
+int history_control = 0;
+
+/* Variables declared in other files used here. */
+extern int interactive;
+extern int current_command_line_count;
+extern int delimiter_depth;
+
+extern char *history_delimiting_chars ();
+extern void maybe_add_history ();	/* forward declaration */
+
+static void bash_add_history ();
+
+/* Load the history list from the history file. */
+void
+load_history ()
+{
+  char *hf;
+
+  /* Truncate history file for interactive shells which desire it.
+     Note that the history file is automatically truncated to the
+     size of HISTSIZE if the user does not explicitly set the size
+     differently. */
+  set_if_not ("HISTFILESIZE", get_string_value ("HISTSIZE"));
+  stupidly_hack_special_variables ("HISTFILESIZE");
+
+  /* Read the history in HISTFILE into the history list. */
+  hf = get_string_value ("HISTFILE");
+
+  if (hf && *hf)
+    {
+      struct stat buf;
+
+      if (stat (hf, &buf) == 0)
+	{
+	  read_history (hf);
+	  using_history ();
+	  history_lines_in_file = where_history ();
+	}
+    }
+}
+
+/* Write the existing history out to the history file. */
+void
+save_history ()
+{
+  char *hf = get_string_value ("HISTFILE");
+
+  if (hf && *hf)
+    {
+      struct stat buf;
+
+      if (stat (hf, &buf) == 0)
+	{
+	  /* Append only the lines that occurred this session to
+	     the history file. */
+	  using_history ();
+
+	  if (history_lines_this_session < where_history ())
+	    append_history (history_lines_this_session, hf);
+	  else
+	    write_history (hf);
+	}
+    }
+}
+
+/* If this is an interactive shell, then append the lines executed
+   this session to the history file. */
+int
+maybe_save_shell_history ()
+{
+  int result = 0;
+
+  if (history_lines_this_session)
+    {
+      char *hf = get_string_value ("HISTFILE");
+
+      if (hf && *hf)
+	{
+	  struct stat buf;
+
+	  /* If the file doesn't exist, then create it. */
+	  if (stat (hf, &buf) == -1)
+	    {
+	      int file = open (hf, O_CREAT | O_TRUNC | O_WRONLY, 0666);
+	      if (file != -1)
+		close (file);
+	    }
+
+	  /* Now actually append the lines if the history hasn't been
+	     stifled.  If the history has been stifled, rewrite the
+	     history file. */
+	  using_history ();
+	  if (history_lines_this_session <= where_history ())
+	    {
+	      result = append_history (history_lines_this_session, hf);
+	      history_lines_in_file += history_lines_this_session;
+	    }
+	  else
+	    {
+	      result = write_history (hf);
+	      history_lines_in_file = history_lines_this_session;
+	    }
+	  history_lines_this_session = 0;
+	}
+    }
+  return (result);
+}
+
+#if defined (HISTORY_REEDITING)
+/* Tell readline () that we have some text for it to edit. */
+static void
+re_edit (text)
+     char *text;
+{
+#if defined (READLINE)
+  if (strcmp (bash_input.name, "readline stdin") == 0)
+    bash_re_edit (text);
+#endif /* READLINE */
+}
+#endif /* HISTORY_REEDITING */
+
+/* Do pre-processing on LINE.  If PRINT_CHANGES is non-zero, then
+   print the results of expanding the line if there were any changes.
+   If there is an error, return NULL, otherwise the expanded line is
+   returned.  If ADDIT is non-zero the line is added to the history
+   list after history expansion.  ADDIT is just a suggestion;
+   REMEMBER_ON_HISTORY can veto, and does.
+   Right now this does history expansion. */
+char *
+pre_process_line (line, print_changes, addit)
+     char *line;
+     int print_changes, addit;
+{
+  char *history_value;
+  char *return_value;
+  int expanded = 0;
+
+  return_value = line;
+
+#  if defined (BANG_HISTORY)
+  /* History expand the line.  If this results in no errors, then
+     add that line to the history if ADDIT is non-zero. */
+  if (!history_expansion_inhibited && history_expansion)
+    {
+      expanded = history_expand (line, &history_value);
+
+      if (expanded)
+	{
+	  if (print_changes)
+	    {
+	      if (expanded < 0)
+		internal_error (history_value);
+	      else
+		fprintf (stderr, "%s\n", history_value);
+	    }
+
+	  /* If there was an error, return NULL. */
+	  if (expanded < 0 || expanded == 2)	/* 2 == print only */
+	    {
+	      free (history_value);
+
+#    if defined (HISTORY_REEDITING)
+	      /* New hack.  We can allow the user to edit the
+		 failed history expansion. */
+	      re_edit (line);
+#    endif /* HISTORY_REEDITING */
+	      return ((char *)NULL);
+	    }
+	}
+
+      /* Let other expansions know that return_value can be free'ed,
+	 and that a line has been added to the history list.  Note
+	 that we only add lines that have something in them. */
+      expanded = 1;
+      return_value = history_value;
+    }
+#  endif /* BANG_HISTORY */
+
+  if (addit && remember_on_history && *return_value)
+    maybe_add_history (return_value);
+
+  if (!expanded)
+    return_value = savestring (line);
+
+  return (return_value);
+}
+
+/* Add LINE to the history list depending on the value of HISTORY_CONTROL. */
+void
+maybe_add_history (line)
+     char *line;
+{
+  int h;
+
+  /* Don't use the value of history_control to affect the second
+     and subsequent lines of a multi-line command when
+     command_oriented_history is enabled. */
+  if (command_oriented_history && current_command_line_count > 1)
+    h = 0;
+  else
+    h = history_control;
+
+  switch (h)
+    {
+    case 0:
+      bash_add_history (line);
+      break;
+    case 1:
+      if (*line != ' ')
+        bash_add_history (line);
+      break;
+    case 3:
+      if (*line == ' ')
+        break;
+      /* FALLTHROUGH if case == 3 (`ignoreboth') */
+    case 2:
+      {
+	HIST_ENTRY *temp;
+
+	using_history ();
+	temp = previous_history ();
+
+	if (!temp || (STREQ (temp->line, line) == 0))
+	  bash_add_history (line);
+
+	using_history ();
+      }
+      break;
+    }
+}
+
+/* Add a line to the history list.
+   The variable COMMAND_ORIENTED_HISTORY controls the style of history
+   remembering;  when non-zero, and LINE is not the first line of a
+   complete parser construct, append LINE to the last history line instead
+   of adding it as a new line. */
+static void
+bash_add_history (line)
+     char *line;
+{
+  int add_it = 1;
+
+  if (command_oriented_history && current_command_line_count > 1)
+    {
+      register int offset;
+      register HIST_ENTRY *current, *old;
+      char *chars_to_add, *new_line;
+
+      chars_to_add = history_delimiting_chars ();
+
+      using_history ();
+
+      current = previous_history ();
+
+      if (current)
+	{
+	  /* If the previous line ended with an escaped newline (escaped
+	     with backslash, but otherwise unquoted), then remove the quoted
+	     newline, since that is what happens when the line is parsed. */
+	  int curlen;
+
+	  curlen = strlen (current->line);
+
+	  if (!delimiter_depth && current->line[curlen - 1] == '\\' &&
+	      current->line[curlen - 2] != '\\')
+	    {
+	      current->line[curlen - 1] = '\0';
+	      curlen--;
+	      chars_to_add = "";
+	    }
+
+	  offset = where_history ();
+	  new_line = (char *) xmalloc (1
+				       + curlen
+				       + strlen (line)
+				       + strlen (chars_to_add));
+	  sprintf (new_line, "%s%s%s", current->line, chars_to_add, line);
+	  old = replace_history_entry (offset, new_line, current->data);
+	  free (new_line);
+
+	  if (old)
+	    {
+	      /* Note that the old data is not freed, since it was simply
+		 copied to the new history entry. */
+	      if (old->line)
+		free (old->line);
+
+	      free (old);
+	    }
+	  add_it = 0;
+	}
+    }
+
+  if (add_it)
+    {
+      add_history (line);
+      history_lines_this_session++;
+    }
+  using_history ();
+}
+
+int
+history_number ()
+{
+  using_history ();
+  if (get_string_value ("HISTSIZE"))
+    return (history_base + where_history ());
+  else
+    return (1);		/* default to command number 1 */
+}

bashhist.h

@@ -0,0 +1,42 @@
+/* bashhist.h -- interface to the bash history functions in bashhist.c. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (__BASHHIST_H__)
+#define __BASHHIST_H__
+
+extern int remember_on_history;
+extern int history_lines_this_session;
+extern int history_lines_in_file;
+extern int history_expansion;
+extern int history_control;
+extern int command_oriented_history;
+
+#  if defined (BANG_HISTORY)
+extern int history_expansion_inhibited;
+#  endif /* BANG_HISTORY */
+
+extern void load_history ();
+extern void save_history ();
+extern int maybe_save_shell_history ();
+extern char *pre_process_line ();
+extern int history_number ();
+extern void maybe_add_history ();
+
+#endif /* __BASHHIST_H__ */

bashtypes.h

@@ -0,0 +1,34 @@
+/* bashtypes.h -- <sys/types.h> with special handling for crays. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (__BASHTYPES_H)
+#  define __BASHTYPES_H
+
+#if defined (CRAY)
+#  define word __word
+#endif
+
+#include <sys/types.h>
+
+#if defined (CRAY)
+#  undef word
+#endif
+
+#endif /* __BASHTYPES_H */

bracecomp.c

@@ -0,0 +1,166 @@
+/* bracecomp.c -- Complete a filename with the possible completions enclosed
+   in csh-style braces such that the list of completions is available to the
+   shell. */
+
+/* Original version by tromey@cns.caltech.edu,  Fri Feb  7 1992. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <stdio.h>
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "shell.h"
+#include <readline/readline.h>
+
+/* Find greatest common prefix of two strings. */
+static int
+string_gcd (s1, s2)
+     char *s1, *s2;
+{
+  register int i;
+
+  if (s1 == NULL || s2 == NULL)
+    return (0);
+
+  for (i = 0; *s1 && *s2; ++s1, ++s2, ++i)
+    {
+      if (*s1 != *s2)
+	break;
+    }
+
+  return (i);
+}
+
+static char *
+really_munge_braces (array, real_start, real_end, gcd_zero)
+     char **array;
+     int real_start, real_end, gcd_zero;
+{
+  int start, end, gcd;
+  char *result, *subterm;
+  int result_size, flag;
+
+  flag = 0;
+
+  if (real_start == real_end)
+    {
+      if (array[real_start])
+        return (savestring (array[real_start] + gcd_zero));
+      else
+        return (savestring (array[0]));
+    }
+
+  result = (char *) xmalloc (result_size = 1);
+  *result = '\0';
+
+  for (start = real_start; start < real_end; start = end + 1)
+    {
+      gcd = strlen (array[start]);
+      for (end = start + 1; end < real_end; end++)
+	{
+	  int temp;
+
+	  temp = string_gcd (array[start], array[end]);
+
+	  if (temp <= gcd_zero)
+	    break;
+
+	  gcd = temp;
+	}
+      end--;
+
+      if (gcd_zero == 0 && start == real_start && end != (real_end - 1))
+	{
+	  /* In this case, add in a leading '{', because we are at
+	     top level, and there isn't a consistent prefix. */
+	  result_size += 1;
+	  result = (char *) xrealloc (result, result_size);
+	  strcpy (result, "{");
+	  flag++;
+	}
+
+      if (start == end)
+	subterm = savestring (array[start] + gcd_zero);
+      else
+	{
+	  /* If there is more than one element in the subarray,
+	     insert the prefix and an opening brace. */
+	  result_size += gcd - gcd_zero + 1;
+	  result = (char *) xrealloc (result, result_size);
+	  strncat (result, array[start] + gcd_zero, gcd - gcd_zero);
+	  strcat (result, "{");
+	  subterm = really_munge_braces (array, start, end + 1, gcd);
+	  subterm[strlen (subterm) - 1] = '}';
+	}
+
+      result_size += strlen (subterm) + 1;
+      result = (char *) xrealloc (result, result_size);
+      strcat (result, subterm);
+      strcat (result, ",");
+      free (subterm);
+    }
+
+  if (gcd_zero == 0)
+    result[strlen (result) - 1] = flag ? '}' : '\0';
+  return (result);
+}
+
+static void
+hack_braces_completion (names)
+     char **names;
+{
+  register int i;
+  char *temp;
+
+  temp = really_munge_braces (names, 1, array_len (names), 0);
+
+  for (i = 0; names[i]; ++i)
+    {
+      free (names[i]);
+      names[i] = NULL;
+    }
+  names[0] = temp;
+}
+
+void
+bash_brace_completion ()
+{
+  Function *orig_ignore_func;
+  Function *orig_entry_func;
+  CPPFunction *orig_attempt_func;
+
+  orig_ignore_func = rl_ignore_some_completions_function;
+  orig_attempt_func = rl_attempted_completion_function;
+  orig_entry_func = rl_completion_entry_function;
+
+  rl_completion_entry_function = (Function *) filename_completion_function;
+  rl_attempted_completion_function = NULL;
+  rl_ignore_some_completions_function = (Function *) hack_braces_completion;
+
+  rl_complete_internal (TAB);
+
+  rl_ignore_some_completions_function = orig_ignore_func;
+  rl_attempted_completion_function = orig_attempt_func;
+  rl_completion_entry_function = orig_entry_func;
+}

braces.c

@@ -0,0 +1,371 @@
+/* braces.c -- code for doing word expansion in curly braces. */
+
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* Stuff in curly braces gets expanded after variable and command
+   substitution, but before filename globbing.
+
+   (Actually, this should be true for the sake of efficiency, but it
+   isn't because of quoting hacks.  Once I rebuild quoting it will be
+   true. */
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#if defined (SHELL)
+#include "shell.h"
+#endif /* SHELL */
+
+#include "general.h"
+#define brace_whitespace(c) (!(c) || (c) == ' ' || (c) == '\t' || (c) == '\n')
+
+/* Basic idea:
+
+   Segregate the text into 3 sections: preamble (stuff before an open brace),
+   postamble (stuff after the matching close brace) and amble (stuff after
+   preamble, and before postamble).  Expand amble, and then tack on the
+   expansions to preamble.  Expand postamble, and tack on the expansions to
+   the result so far.
+ */
+
+/* The character which is used to separate arguments. */
+int brace_arg_separator = ',';
+
+static int brace_gobbler ();
+static char **expand_amble (), **array_concat ();
+
+/* Return an array of strings; the brace expansion of TEXT. */
+char **
+brace_expand (text)
+     char *text;
+{
+  register int start;
+  char *preamble, *postamble, *amble;
+  char **tack, **result;
+  int i, c;
+
+  /* Find the text of the preamble. */
+  i = 0;
+  c = brace_gobbler (text, &i, '{');
+
+  preamble = (char *)xmalloc (i + 1);
+  strncpy (preamble, text, i);
+  preamble[i] = '\0';
+
+  result = (char **)xmalloc (2 * sizeof (char *));
+  result[0] = preamble;
+  result[1] = (char *)NULL;
+  
+  /* Special case.  If we never found an exciting character, then
+     the preamble is all of the text, so just return that. */
+  if (c != '{')
+    return (result);
+
+  /* Find the amble.  This is the stuff inside this set of braces. */
+  start = ++i;
+  c = brace_gobbler (text, &i, '}');
+
+  /* What if there isn't a matching close brace? */
+  if (!c)
+    {
+#if defined (NOTDEF)
+      register int j;
+
+      /* Well, if we found an unquoted BRACE_ARG_SEPARATOR between START
+	 and I, then this should be an error.  Otherwise, it isn't. */
+      for (j = start; j < i; j++)
+	{
+	  if (text[j] == '\\')
+	    {
+	      j++;
+	      continue;
+	    }
+
+	  if (text[j] == brace_arg_separator)
+	    {
+	      free_array (result);
+	      report_error ("Missing `}'");
+	      throw_to_top_level ();
+	    }
+	}
+#endif
+      free (preamble);		/* Same as result[0]; see initialization. */
+      result[0] = savestring (text);
+      return (result);
+    }
+
+  amble = (char *)xmalloc (1 + (i - start));
+  strncpy (amble, &text[start], (i - start));
+  amble[i - start] = '\0';
+
+#if defined (SHELL)
+  /* If the amble does not contain an unquoted BRACE_ARG_SEPARATOR, then
+     just return without doing any expansion.  */
+  {
+    register int j;
+
+    for (j = 0; amble[j]; j++)
+      {
+	if (amble[j] == '\\')
+	  {
+	    j++;
+	    continue;
+	  }
+	if (amble[j] == brace_arg_separator)
+	  break;
+      }
+
+    if (!amble[j])
+      {
+	free (amble);
+	free (preamble);
+	result[0] = savestring (text);
+	return (result);
+      }
+  }
+#endif /* SHELL */
+
+  postamble = &text[i + 1];
+
+  tack = expand_amble (amble);
+  result = array_concat (result, tack);
+  free (amble);
+  free_array (tack);
+
+  tack = brace_expand (postamble);
+  result = array_concat (result, tack);
+  free_array (tack);
+
+  return (result);
+}
+
+/* Expand the text found inside of braces.  We simply try to split the
+   text at BRACE_ARG_SEPARATORs into separate strings.  We then brace
+   expand each slot which needs it, until there are no more slots which
+   need it. */
+static char **
+expand_amble (text)
+     char *text;
+{
+  char **result, **partial;
+  char *tem;
+  int start, i, c;
+
+  result = (char **)NULL;
+
+  for (start = 0, i = 0, c = 1; c; start = ++i)
+    {
+      c = brace_gobbler (text, &i, brace_arg_separator);
+      tem = (char *)xmalloc (1 + (i - start));
+      strncpy (tem, &text[start], (i - start));
+      tem[i- start] = '\0';
+
+      partial = brace_expand (tem);
+
+      if (!result)
+	result = partial;
+      else
+	{
+	  register int lr = array_len (result);
+	  register int lp = array_len (partial);
+	  register int j;
+
+	  result = (char **)xrealloc (result, (1 + lp + lr) * sizeof (char *));
+
+	  for (j = 0; j < lp; j++)
+	    result[lr + j] = partial[j];
+
+	  result[lr + j] = (char *)NULL;
+	  free (partial);
+	}
+      free (tem);
+    }
+  return (result);
+}
+
+/* Start at INDEX, and skip characters in TEXT. Set INDEX to the
+   index of the character matching SATISFY.  This understands about
+   quoting.  Return the character that caused us to stop searching;
+   this is either the same as SATISFY, or 0. */
+static int
+brace_gobbler (text, indx, satisfy)
+     char *text;
+     int *indx;
+     int satisfy;
+{
+  register int i, c, quoted, level, pass_next;
+
+  level = quoted = pass_next = 0;
+
+  for (i = *indx; c = text[i]; i++)
+    {
+      if (pass_next)
+	{
+	  pass_next = 0;
+	  continue;
+	}
+
+      /* A backslash escapes the next character.  This allows backslash to
+	 escape the quote character in a double-quoted string. */
+      if (c == '\\' && (quoted == 0 || quoted == '"' || quoted == '`'))
+        {
+          pass_next = 1;
+          continue;
+        }
+
+      if (quoted)
+	{
+	  if (c == quoted)
+	    quoted = 0;
+	  continue;
+	}
+
+      if (c == '"' || c == '\'' || c == '`')
+	{
+	  quoted = c;
+	  continue;
+	}
+      
+      if (c == satisfy && !level && !quoted)
+	{
+	  /* We ignore an open brace surrounded by whitespace, and also
+	     an open brace followed immediately by a close brace, that
+	     was preceded with whitespace.  */
+	  if (c == '{' &&
+	      ((!i || brace_whitespace (text[i - 1])) &&
+	       (brace_whitespace (text[i + 1]) || text[i + 1] == '}')))
+	    continue;
+#if defined (SHELL)
+	  /* If this is being compiled as part of bash, ignore the `{'
+	     in a `${}' construct */
+	  if ((c != '{') || !i || (text[i - 1] != '$'))
+#else /* !SHELL */
+	  if ((c != '{') || !i)
+#endif /* !SHELL */
+	    break;
+	}
+
+      if (c == '{')
+	level++;
+      else if (c == '}' && level)
+	level--;
+    }
+
+  *indx = i;
+  return (c);
+}
+
+/* Return a new array of strings which is the result of appending each
+   string in ARR2 to each string in ARR1.  The resultant array is
+   len (arr1) * len (arr2) long.  For convenience, ARR1 (and its contents)
+   are free ()'ed.  ARR1 can be NULL, in that case, a new version of ARR2
+   is returned. */
+static char **
+array_concat (arr1, arr2)
+     char **arr1, **arr2;
+{
+  register int i, j, len, len1, len2;
+  register char **result;
+
+  if (!arr1)
+    return (copy_array (arr2));
+
+  if (!arr2)
+    return (copy_array (arr1));
+
+  len1 = array_len (arr1);
+  len2 = array_len (arr2);
+
+  result = (char **)xmalloc ((1 + (len1 * len2)) * sizeof (char *));
+
+  len = 0;
+  for (i = 0; i < len1; i++)
+    {
+      int strlen_1 = strlen (arr1[i]);
+
+      for (j = 0; j < len2; j++)
+	{
+	  result[len] =
+	    (char *)xmalloc (1 + strlen_1 + strlen (arr2[j]));
+	  strcpy (result[len], arr1[i]);
+	  strcpy (result[len] + strlen_1, arr2[j]);
+	  len++;
+	}
+      free (arr1[i]);
+    }
+  free (arr1);
+
+  result[len] = (char *)NULL;
+  return (result);
+}
+
+#if defined (TEST)
+#include <stdio.h>
+
+fatal_error (format, arg1, arg2)
+     char *format, *arg1, *arg2;
+{
+  report_error (format, arg1, arg2);
+  exit (1);
+}
+
+report_error (format, arg1, arg2)
+     char *format, *arg1, *arg2;
+{
+  fprintf (stderr, format, arg1, arg2);
+  fprintf (stderr, "\n");
+}
+
+main ()
+{
+  char example[256];
+
+  for (;;)
+    {
+      char **result;
+      int i;
+
+      fprintf (stderr, "brace_expand> ");
+
+      if ((!fgets (example, 256, stdin)) ||
+	  (strncmp (example, "quit", 4) == 0))
+	break;
+
+      if (strlen (example))
+	example[strlen (example) - 1] = '\0';
+
+      result = brace_expand (example);
+
+      for (i = 0; result[i]; i++)
+	printf ("%s\n", result[i]);
+
+      free_array (result);
+    }
+}
+
+/*
+ * Local variables:
+ * compile-command: "gcc -g -Bstatic -DTEST -o brace_expand braces.c general.o"
+ * end:
+ */
+
+#endif /* TEST */

builtins.h

@@ -0,0 +1,45 @@
+/* builtins.h -- What a builtin looks like, and where to find them. */
+
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "config.h"
+#include "command.h"
+#include "general.h"
+
+#if defined (ALIAS)
+#include "alias.h"
+#endif
+
+/* Flags describing various things about a builtin. */
+#define BUILTIN_ENABLED 0x1	/* This builtin is enabled. */
+#define STATIC_BUILTIN  0x2	/* This builtin is not dynamically loaded. */
+#define SPECIAL_BUILTIN 0x4	/* This is a Posix `special' builtin. */
+
+/* The thing that we build the array of builtins out of. */
+struct builtin {
+  char *name;			/* The name that the user types. */
+  Function *function;		/* The address of the invoked function. */
+  int flags;			/* One of the #defines above. */
+  char **long_doc;		/* NULL terminated array of strings. */
+  char *short_doc;		/* Short version of documenation. */
+};
+
+/* Found in builtins.c, created by builtins/mkbuiltins. */
+extern int num_shell_builtins;	/* Number of shell builtins. */
+extern struct builtin shell_builtins[];

builtins/Makefile

@@ -0,0 +1,267 @@
+# This Makefile for building libbuiltins.a is in -*- text -*- for Emacs.
+#
+MKBUILTINS = mkbuiltins
+RANLIB = /usr/bin/ranlib
+CFLAGS = -g -I.. -I.
+SHELL = /bin/sh
+# CC = cc
+AR = ar
+RM = rm -f
+CP = cp
+
+srcdir = .
+VPATH = .:$(srcdir)
+
+.SUFFIXES:
+.SUFFIXES: .def .c .o
+# How to make a .o file from a .def file.
+.def.o:
+	$(RM) $@
+	./$(MKBUILTINS) $(DIRECTDEFINE) $<
+	$(CC) -c $(CFLAGS) $(CPPFLAGS) $*.c || ( $(RM) $*.c ; exit 1 )
+	$(RM) $*.c
+
+# How to make a .c file from a .def file.
+.def.c:
+	$(RM) $@
+	./$(MKBUILTINS) $(DIRECTDEFINE) $<
+
+# Here is a rule for making .o files from .c files that does not
+# force the type of the machine (like -M_MACHINE) into the flags.
+.c.o:
+	$(RM) $@
+	$(CC) -c $(CFLAGS) $(CPPFLAGS) $<
+
+DEFS =  $(srcdir)/alias.def $(srcdir)/bind.def $(srcdir)/break.def \
+	$(srcdir)/builtin.def $(srcdir)/cd.def $(srcdir)/colon.def \
+	$(srcdir)/command.def $(srcdir)/declare.def $(srcdir)/echo.def \
+	$(srcdir)/enable.def $(srcdir)/eval.def $(srcdir)/getopts.def \
+	$(srcdir)/exec.def $(srcdir)/exit.def $(srcdir)/fc.def \
+	$(srcdir)/fg_bg.def $(srcdir)/hash.def $(srcdir)/help.def \
+	$(srcdir)/history.def $(srcdir)/jobs.def $(srcdir)/kill.def \
+	$(srcdir)/let.def $(srcdir)/read.def $(srcdir)/return.def \
+	$(srcdir)/set.def $(srcdir)/setattr.def $(srcdir)/shift.def \
+	$(srcdir)/source.def $(srcdir)/suspend.def $(srcdir)/test.def \
+	$(srcdir)/times.def $(srcdir)/trap.def $(srcdir)/type.def \
+	$(srcdir)/ulimit.def $(srcdir)/umask.def $(srcdir)/wait.def \
+	$(srcdir)/reserved.def
+
+STATIC_SOURCE = common.c getopt.c bashgetopt.c getopt.h 
+
+OFILES = builtins.o \
+	alias.o bind.o break.o builtin.o cd.o colon.o command.o \
+	common.o declare.o echo.o enable.o eval.o exec.o exit.o \
+	fc.o fg_bg.o hash.o help.o history.o jobs.o kill.o \
+	let.o read.o return.o set.o setattr.o shift.o source.o \
+	suspend.o test.o times.o trap.o type.o ulimit.o umask.o \
+	wait.o getopts.o getopt.o bashgetopt.o
+
+THINGS_TO_TAR = $(DEFS) $(STATIC_SOURCE) Makefile ChangeLog
+
+CREATED_FILES = builtext.h builtins.c psize.aux pipesize.h
+
+all: $(MKBUILTINS) libbuiltins.a
+
+libbuiltins.a: $(MKBUILTINS) $(OFILES)
+	$(RM) $@
+	$(AR) cq $@ $(OFILES)
+	-$(RANLIB) $@
+
+builtext.h builtins.c: $(MKBUILTINS) $(DEFS)
+	$(RM) builtext.h builtins.c
+	./$(MKBUILTINS) -externfile builtext.h -structfile builtins.c \
+	-noproduction $(DIRECTDEFINE) $(DEFS)
+
+mkbuiltins: $(srcdir)/mkbuiltins.c ../config.h
+	$(CC) $(CFLAGS) -o $(MKBUILTINS) $(srcdir)/mkbuiltins.c
+
+ulimit.o: ulimit.def pipesize.h
+
+pipesize.h:	psize.aux
+	$(SHELL) $(srcdir)/psize.sh > pipesize.h
+
+psize.aux:	psize.c
+	$(CC) $(CFLAGS) -o $@ $(srcdir)/psize.c
+
+documentation: builtins.texi
+
+$(OFILES):	$(MKBUILTINS) ../config.h
+
+builtins.texi: $(MKBUILTINS)
+	./$(MKBUILTINS) -documentonly $(DEFS)
+
+clean:
+	$(RM) $(OFILES) $(CREATED_FILES) $(MKBUILTINS)
+
+mostlyclean:
+	$(RM) $(OFILES) libbuiltins.a
+
+distclean realclean maintainer-clean: clean
+	$(RM) libbuiltins.a
+
+alias.o: alias.def
+bind.o: bind.def
+break.o: break.def
+builtin.o: builtin.def
+cd.o: cd.def
+colon.o: colon.def
+command.o: command.def
+declare.o: declare.def
+echo.o: echo.def
+enable.o: enable.def
+eval.o: eval.def
+exec.o: exec.def
+exit.o: exit.def
+fc.o: fc.def
+fg_bg.o: fg_bg.def
+hash.o: hash.def
+help.o: help.def
+history.o: history.def
+jobs.o: jobs.def
+kill.o: kill.def
+let.o: let.def
+read.o: read.def
+return.o: return.def
+set.o: set.def
+setattr.o: setattr.def
+shift.o: shift.def
+source.o: source.def
+suspend.o: suspend.def
+test.o: test.def
+times.o: times.def
+trap.o: trap.def
+type.o: type.def
+umask.o: umask.def
+wait.o: wait.def
+getopts.o: getopts.def
+reserved.o: reserved.def
+
+common.o: ../shell.h ../command.h ../config.h ../memalloc.h ../general.h
+common.o: ../variables.h ../input.h hashcom.h ../bashhist.h
+common.o: ../quit.h  ../unwind_prot.h ../maxpath.h ../jobs.h ../builtins.h
+common.o: ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+common.o: ../execute_cmd.h ../error.h
+alias.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+alias.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+alias.o: ../shell.h ../unwind_prot.h ../variables.h common.h ../maxpath.h
+bind.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+bind.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+bind.o: ../maxpath.h
+bind.o: ../shell.h ../unwind_prot.h ../variables.h bashgetopt.h
+break.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+break.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+break.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+builtin.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+builtin.o: ../quit.h common.h ../maxpath.h
+builtin.o: ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+builtin.o: ../shell.h ../unwind_prot.h ../variables.h 
+cd.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+cd.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+cd.o: ../shell.h ../unwind_prot.h ../variables.h common.h ../maxpath.h
+command.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+command.o: ../quit.h bashgetopt.h ../maxpath.h
+command.o: ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+command.o: ../shell.h ../unwind_prot.h ../variables.h 
+declare.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+declare.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+declare.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+echo.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+echo.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+echo.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+enable.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+enable.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+enable.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+eval.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+eval.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+eval.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+exec.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+exec.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+exec.o: ../shell.h ../unwind_prot.h ../variables.h common.h ../execute_cmd.h
+exec.o: ../maxpath.h ../flags.h
+exit.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+exit.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+exit.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+fc.o: ../builtins.h ../command.h bashgetopt.h ../bashhist.h
+fc.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+fc.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+fc.o: ../flags.h ../unwind_prot.h ../variables.h ../shell.h ../maxpath.h
+fg_bg.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+fg_bg.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+fg_bg.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+getopts.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+getopts.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+getopts.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+hash.o: ../builtins.h ../command.h ../quit.h ../execute_cmd.h
+hash.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+hash.o: ../shell.h ../unwind_prot.h ../variables.h common.h ../maxpath.h
+help.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+help.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+help.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+history.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+history.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+history.o: ../filecntl.h ../shell.h ../unwind_prot.h ../variables.h
+history.o: ../bashhist.h ../maxpath.h
+inlib.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+inlib.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+inlib.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+jobs.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+jobs.o: ../quit.h bashgetopt.h ../maxpath.h
+jobs.o: ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+jobs.o: ../shell.h ../unwind_prot.h ../variables.h 
+kill.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+kill.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+kill.o: ../shell.h ../trap.h ../unwind_prot.h ../variables.h ../maxpath.h
+let.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+let.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+let.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+read.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+read.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+read.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+return.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+return.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+return.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+set.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+set.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+set.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+setattr.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+setattr.o: ../quit.h common.h bashgetopt.h ../maxpath.h
+setattr.o: ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+setattr.o: ../shell.h ../unwind_prot.h ../variables.h 
+shift.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+shift.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+shift.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+source.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+source.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+source.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+suspend.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+suspend.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+suspend.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+test.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+test.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+test.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+times.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+times.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+times.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+trap.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+trap.o: ../quit.h common.h ../maxpath.h
+trap.o: ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+trap.o: ../shell.h ../unwind_prot.h ../variables.h ../execute_cmd.h
+type.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+type.o: ../quit.h common.h ../maxpath.h
+type.o: ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+type.o: ../shell.h ../unwind_prot.h ../variables.h 
+ulimit.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+ulimit.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+ulimit.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+umask.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+umask.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+umask.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+wait.o: ../command.h ../config.h ../memalloc.h ../error.h ../general.h
+wait.o: ../quit.h ../dispose_cmd.h ../make_cmd.h ../subst.h ../externs.h
+wait.o: ../shell.h ../unwind_prot.h ../variables.h ../maxpath.h
+
+bashgetopt.o: ../bashansi.h ../ansi_stdlib.h
+mkbuiltins.o: ../bashansi.h ../ansi_stdlib.h
+fc.o: ../bashansi.h ../ansi_stdlib.h
+
+#bind.o: $(RL_LIBSRC)chardefs.h $(RL_LIBSRC)readline.h $(RL_LIBSRC)keymaps.h

builtins/alias.def

@@ -0,0 +1,180 @@
+This file is alias.def, from which is created alias.c
+It implements the builtins "alias" and "unalias" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$BUILTIN alias
+$FUNCTION alias_builtin
+$DEPENDS_ON ALIAS
+$PRODUCES alias.c
+$SHORT_DOC alias [ name[=value] ... ]
+`alias' with no arguments prints the list of aliases in the form
+NAME=VALUE on standard output.  An alias is defined for each NAME
+whose VALUE is given.  A trailing space in VALUE causes the next
+word to be checked for alias substitution.  Alias returns true
+unless a NAME is given for which no alias has been defined.
+$END
+
+#include "../config.h"
+
+#if defined (ALIAS)
+#  include <stdio.h>
+#  include "../shell.h"
+#  include "../alias.h"
+#  include "common.h"
+
+extern int interactive;
+static void print_alias ();
+
+/* Hack the alias command in a Korn shell way. */
+alias_builtin (list)
+     WORD_LIST *list;
+{
+  int any_failed = 0;
+
+  if (!list)
+    {
+      register int i;
+      ASSOC **alias_list;
+
+      if (!aliases)
+	return (EXECUTION_FAILURE);
+
+      alias_list = all_aliases ();
+
+      if (!alias_list)
+	return (EXECUTION_FAILURE);
+
+      for (i = 0; alias_list[i]; i++)
+	print_alias (alias_list[i]);
+
+      free (alias_list);	/* XXX - Do not free the strings. */
+    }
+  else
+    {
+      while (list)
+	{
+	  register char *value, *name = list->word->word;
+	  register int offset;
+
+	  for (offset = 0; name[offset] && name[offset] != '='; offset++)
+	    ;
+
+	  if (offset && name[offset] == '=')
+	    {
+	      name[offset] = '\0';
+	      value = name + offset + 1;
+
+	      add_alias (name, value);
+	    }
+	  else
+	    {
+	      ASSOC *t = find_alias (name);
+	      if (t)
+		print_alias (t);
+	      else
+		{
+		  if (interactive)
+		    builtin_error ("`%s' not found", name);
+		  any_failed++;
+		}
+	    }
+	  list = list->next;
+	}
+    }
+  if (any_failed)
+    return (EXECUTION_FAILURE);
+  else
+    return (EXECUTION_SUCCESS);
+}
+#endif /* ALIAS */
+
+$BUILTIN unalias
+$FUNCTION unalias_builtin
+$DEPENDS_ON ALIAS
+$SHORT_DOC unalias [-a] [name ...]
+Remove NAMEs from the list of defined aliases.  If the -a option is given,
+then remove all alias definitions.
+$END
+
+#if defined (ALIAS)
+/* Remove aliases named in LIST from the aliases database. */
+unalias_builtin (list)
+     register WORD_LIST *list;
+{
+  register ASSOC *alias;
+  int any_failed = 0;
+
+  while (list && *list->word->word == '-')
+    {
+      register char *word = list->word->word;
+
+      if (ISOPTION (word, 'a'))
+	{
+	  delete_all_aliases ();
+	  list = list->next;
+	}
+      else if (ISOPTION (word, '-'))
+	{
+	  list = list->next;
+	  break;
+	}
+      else
+	{
+	  bad_option (word);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+
+  while (list)
+    {
+      alias = find_alias (list->word->word);
+
+      if (alias)
+	remove_alias (alias->name);
+      else
+	{
+	  if (interactive)
+	    builtin_error ("`%s' not an alias", list->word->word);
+
+	  any_failed++;
+	}
+
+      list = list->next;
+    }
+
+  if (any_failed)
+    return (EXECUTION_FAILURE);
+  else
+    return (EXECUTION_SUCCESS);
+}
+
+/* Output ALIAS in such a way as to allow it to be read back in. */
+static void
+print_alias (alias)
+     ASSOC *alias;
+{
+  char *value = single_quote (alias->value);
+
+  printf ("alias %s=%s\n", alias->name, value);
+  free (value);
+
+  fflush (stdout);
+}
+#endif /* ALIAS */

builtins/bashgetopt.c

@@ -0,0 +1,136 @@
+/* bashgetopt.c -- `getopt' for use by the builtins. */
+
+/* Copyright (C) 1992 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <errno.h>
+#include "shell.h"
+
+#include "bashansi.h"
+
+#define ERR(S, C)	builtin_error("%s%c", (S), (C))
+
+static int	sp;
+
+char    *list_optarg;
+int	list_optopt;
+
+static WORD_LIST *lhead = (WORD_LIST *)NULL;
+WORD_LIST	*lcurrent = (WORD_LIST *)NULL;
+WORD_LIST	*loptend;	/* Points to the first non-option argument in the list */
+
+int
+internal_getopt(list, opts)
+WORD_LIST	*list;
+char		*opts;
+{
+	register int c;
+	register char *cp;
+
+	if (!list) {
+		list_optarg = (char *)NULL;
+		loptend = (WORD_LIST *)NULL;	/* No non-option arguments */
+		return -1;
+	}
+
+	if (list != lhead || !lhead) {
+		/* Hmmm.... called with a different word list.  Reset. */
+		sp = 1;
+		lcurrent = lhead = list;
+		loptend = (WORD_LIST *)NULL;
+	}
+
+	if (sp == 1) {
+		if (!lcurrent ||
+		    (lcurrent->word->word[0] != '-' || lcurrent->word->word[1] == '\0')) {
+		    	lhead = (WORD_LIST *)NULL;
+		    	loptend = lcurrent;
+			return(-1);
+		} else if (lcurrent->word->word[0] == '-' &&
+			   lcurrent->word->word[1] == '-' &&
+			   lcurrent->word->word[2] == 0) {
+			lhead = (WORD_LIST *)NULL;
+			loptend = lcurrent->next;
+			return(-1);
+		}
+	}
+
+	list_optopt = c = lcurrent->word->word[sp];
+
+	if (c == ':' || (cp = strchr(opts, c)) == NULL) {
+		ERR("illegal option: -", c);
+		if (lcurrent->word->word[++sp] == '\0') {
+			lcurrent = lcurrent->next;
+			sp = 1;
+		}
+		list_optarg = NULL;
+		if (lcurrent)
+			loptend = lcurrent->next;
+		return('?');
+	}
+
+	if (*++cp == ':') {
+		/* Option requires an argument. */
+		/* We allow -l2 as equivalent to -l 2 */
+		if (lcurrent->word->word[sp+1] != '\0') {
+			list_optarg = &(lcurrent->word->word[sp+1]);
+			lcurrent = lcurrent->next;
+		} else if (lcurrent->next == NULL) {
+			ERR("option requires an argument: -", c);
+			sp = 1;
+			list_optarg = (char *)NULL;
+			return('?');
+		} else {
+			lcurrent = lcurrent->next;
+			list_optarg = lcurrent->word->word;
+			lcurrent = lcurrent->next;
+		}
+		sp = 1;
+	} else {
+		/* No argument, just return the option. */
+		if (lcurrent->word->word[++sp] == '\0') {
+			sp = 1;
+			lcurrent = lcurrent->next;
+		}
+		list_optarg = (char *)NULL;
+	}
+
+	return(c);
+}
+
+/*
+ * reset_internal_getopt -- force the in[ft]ernal getopt to reset
+ */
+
+void
+reset_internal_getopt ()
+{
+	lhead = lcurrent = loptend = (WORD_LIST *)NULL;
+	sp = 1;
+}
+
+void
+report_bad_option ()
+{
+	char s[3];
+
+	s[0] = '-';
+	s[1] = list_optopt;
+	s[2] = '\0';
+	bad_option (s);
+}

builtins/bashgetopt.h

@@ -0,0 +1,37 @@
+/* bashgetopt.h -- extern declarations for stuff defined in bashgetopt.c. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/* See getopt.h for the explanation of these variables. */
+
+#if !defined (__BASH_GETOPT_H)
+#  define __BASH_GETOPT_H
+
+extern char *list_optarg;
+
+extern int list_optopt;
+
+extern WORD_LIST *lcurrent;
+extern WORD_LIST *loptend;
+
+extern int internal_getopt ();
+extern void reset_internal_getopt ();
+extern void report_bad_option ();
+
+#endif /* !__BASH_GETOPT_H */

builtins/bind.def

@@ -0,0 +1,219 @@
+This file is bind.def, from which is created bind.c.
+It implements the builtin "bind" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES bind.c
+
+$BUILTIN bind
+$DEPENDS_ON READLINE
+$FUNCTION bind_builtin
+$SHORT_DOC bind [-lvd] [-m keymap] [-f filename] [-q name] [keyseq:readline-function]
+Bind a key sequence to a Readline function, or to a macro.  The
+syntax is equivalent to that found in ~/.inputrc, but must be
+passed as a single argument: bind '"\C-x\C-r": re-read-init-file'.
+Arguments we accept:
+  -m  keymap         Use `keymap' as the keymap for the duration of this
+                     command.  Acceptable keymap names are emacs,
+                     emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,
+                     vi-command, and vi-insert.
+  -l                 List names of functions.
+  -v                 List function names and bindings.
+  -d                 Dump functions and bindings such that they
+                     can be read back in.
+  -f  filename       Read key bindings from FILENAME.
+  -q  function-name  Query about which keys invoke the named function.
+$END
+
+#include <stdio.h>
+#include "../shell.h"
+#if defined (READLINE)
+#include <errno.h>
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+#include <readline/readline.h>
+#include <readline/history.h>
+#include "bashgetopt.h"
+
+static int query_bindings ();
+
+extern int bash_readline_initialized;
+extern int no_line_editing;
+
+#define BIND_RETURN(x)  do { return_code = x; goto bind_exit; } while (0)
+
+#define USAGE "usage: bind [-lvd] [-m keymap] [-f filename] [-q name] [keyseq:readline_func]"
+
+int
+bind_builtin (list)
+     WORD_LIST *list;
+{
+  int return_code = EXECUTION_SUCCESS;
+  FILE *old_rl_outstream;
+  Keymap kmap, saved_keymap;
+  int lflag, dflag, fflag, vflag, qflag, mflag, opt;
+  char *initfile, *map_name, *fun_name;
+
+  if (no_line_editing)
+    return (EXECUTION_FAILURE);
+
+  kmap = saved_keymap = (Keymap) NULL;
+  lflag = dflag = vflag = fflag = qflag = mflag = 0;
+  initfile = map_name = fun_name = (char *)NULL;
+
+  if (!bash_readline_initialized)
+    initialize_readline ();
+
+  /* Cannot use unwind_protect_pointer () on "FILE *", it is only
+     guaranteed to work for strings. */
+  /* XXX -- see if we can use unwind_protect here */
+  old_rl_outstream = rl_outstream;
+  rl_outstream = stdout;
+
+  reset_internal_getopt ();  
+  while ((opt = internal_getopt (list, "lvdf:q:m:")) != EOF)
+    {
+      switch (opt)
+	{
+	case 'l':
+	  lflag++;
+	  break;
+
+	case 'v':
+	  vflag++;
+	  break;
+
+	case 'd':
+	  dflag++;
+	  break;
+
+	case 'f':
+	  fflag++;
+	  initfile = list_optarg;
+	  break;
+
+	case 'm':
+	  mflag++;
+	  map_name = list_optarg;
+	  break;
+
+	case 'q':
+	  qflag++;
+	  fun_name = list_optarg;
+	  break;
+
+	default:
+	  builtin_error (USAGE);
+	  BIND_RETURN (EX_USAGE);
+	}
+    }
+
+  list = loptend;
+
+  /* First, see if we need to install a special keymap for this
+     command.  Then start on the arguments. */
+
+  if (mflag && map_name)
+    {
+      kmap = rl_get_keymap_by_name (map_name);
+      if (!kmap)
+        {
+          builtin_error ("`%s': illegal keymap name", map_name);
+	  BIND_RETURN (EXECUTION_FAILURE);
+        }
+    }
+
+  if (kmap)
+    {
+      saved_keymap = rl_get_keymap ();
+      rl_set_keymap (kmap);
+    }
+
+  /* XXX - we need to add exclusive use tests here.  It doesn't make sense
+     to use some of these options together. */
+  /* Now hack the option arguments */
+  if (lflag)
+    rl_list_funmap_names (0);
+
+  if (vflag)
+    rl_function_dumper (0);
+
+  if (dflag)
+    rl_function_dumper (1);
+
+  if (fflag && initfile)
+    {
+      if (rl_read_init_file (initfile) != 0)
+	{
+	  builtin_error ("cannot read %s: %s", initfile, strerror (errno));
+	  BIND_RETURN (EXECUTION_FAILURE);
+	}
+    }
+
+  if (qflag && fun_name)
+    return_code = query_bindings (fun_name);
+
+  /* Process the rest of the arguments as binding specifications. */
+  while (list)
+    {
+      rl_parse_and_bind (list->word->word);
+      list = list->next;
+    }
+
+ bind_exit:
+  if (saved_keymap)
+    rl_set_keymap (saved_keymap);
+
+  rl_outstream = old_rl_outstream;
+  return (return_code);
+}
+
+static int
+query_bindings (name)
+     char *name;
+{
+  Function *function;
+  char **keyseqs;
+  int j;
+
+  function = rl_named_function (name);
+  if (!function)
+    {
+      builtin_error ("unknown function name `%s'", name);
+      return EXECUTION_FAILURE;
+    }
+
+  keyseqs = rl_invoking_keyseqs (function);
+
+  if (!keyseqs)
+    {
+      printf ("%s is not bound to any keys.\n", name);
+      return EXECUTION_FAILURE;
+    }
+
+  printf ("%s can be invoked via ", name);
+  for (j = 0; j < 5 && keyseqs[j]; j++)
+    printf ("\"%s\"%s", keyseqs[j], keyseqs[j + 1] ? ", " : ".\n");
+  if (keyseqs[j])
+    printf ("...\n");
+  free_array (keyseqs);
+  return EXECUTION_SUCCESS;
+}
+#endif /* READLINE */

builtins/break.def

@@ -0,0 +1,110 @@
+This file is break.def, from which is created break.c.
+It implements the builtins "break" and "continue" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES break.c
+
+$BUILTIN break
+$FUNCTION break_builtin
+$SHORT_DOC break [n]
+Exit from within a FOR, WHILE or UNTIL loop.  If N is specified,
+break N levels.
+$END
+
+#include "../shell.h"
+
+extern char *this_command_name;
+
+static int check_loop_level ();
+
+/* The depth of while's and until's. */
+int loop_level = 0;
+
+/* Non-zero when a "break" instruction is encountered. */
+int breaking = 0;
+
+/* Non-zero when we have encountered a continue instruction. */
+int continuing = 0;
+
+/* Set up to break x levels, where x defaults to 1, but can be specified
+   as the first argument. */
+break_builtin (list)
+     WORD_LIST *list;
+{
+  int newbreak;
+
+  if (!check_loop_level ())
+    return (EXECUTION_FAILURE);
+
+  newbreak = get_numeric_arg (list);
+
+  if (newbreak <= 0)
+    return (EXECUTION_FAILURE);
+
+  if (newbreak > loop_level)
+    newbreak = loop_level;
+
+  breaking = newbreak;
+
+  return (EXECUTION_SUCCESS);
+}
+
+$BUILTIN continue
+$FUNCTION continue_builtin
+$SHORT_DOC continue [n]
+Resume the next iteration of the enclosing FOR, WHILE or UNTIL loop.
+If N is specified, resume at the N-th enclosing loop.
+$END
+
+/* Set up to continue x levels, where x defaults to 1, but can be specified
+   as the first argument. */
+continue_builtin (list)
+     WORD_LIST *list;
+{
+  int newcont;
+
+  if (!check_loop_level ())
+    return (EXECUTION_FAILURE);
+
+  newcont = get_numeric_arg (list);
+
+  if (newcont <= 0)
+    return (EXECUTION_FAILURE);
+
+  if (newcont > loop_level)
+    newcont = loop_level;
+
+  continuing = newcont;
+
+  return (EXECUTION_SUCCESS);
+}
+
+/* Return non-zero if a break or continue command would be okay.
+   Print an error message if break or continue is meaningless here. */
+static int
+check_loop_level ()
+{
+#if defined (BREAK_COMPLAINS)
+  if (!loop_level)
+    builtin_error ("Only meaningful in a `for', `while', or `until' loop");
+#endif /* BREAK_COMPLAINS */
+
+  return (loop_level);
+}

builtins/builtin.def

@@ -0,0 +1,67 @@
+This file is builtin.def, from which is created builtin.c.
+It implements the builtin "builtin" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES builtin.c
+
+$BUILTIN builtin
+$FUNCTION builtin_builtin
+$SHORT_DOC builtin [shell-builtin [arg ...]]
+Run a shell builtin.  This is useful when you wish to rename a
+shell builtin to be a function, but need the functionality of the
+builtin within the function itself.
+$END
+
+#include "../shell.h"
+
+#include "common.h"
+
+extern char *this_command_name;
+
+/* Run the command mentioned in list directly, without going through the
+   normal alias/function/builtin/filename lookup process. */
+builtin_builtin (list)
+     WORD_LIST *list;
+{
+  Function *function;
+  register char *command;
+
+  if (!list)
+    return (EXECUTION_SUCCESS);
+
+  command = (list->word->word);
+#if defined (DISABLED_BUILTINS)
+  function = builtin_address (command);
+#else /* !DISABLED_BUILTINS */
+  function = find_shell_builtin (command);
+#endif /* !DISABLED_BUILTINS */
+
+  if (!function)
+    {
+      builtin_error ("%s: not a shell builtin", command);
+      return (EXECUTION_FAILURE);
+    }
+  else
+    {
+      this_command_name = command;
+      list = list->next;
+      return ((*function) (list));
+    }
+}

builtins/cd.def

@@ -0,0 +1,689 @@
+This file is cd.def, from which is created cd.c.  It implements the
+builtins "cd", "pwd", "pushd", "popd", and "dirs" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES cd.c
+
+#include <stdio.h>
+#include <sys/param.h>
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include <errno.h>
+#include <tilde/tilde.h>
+
+#include "../shell.h"
+#include "../flags.h"
+#include "../maxpath.h"
+#include "common.h"
+
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+
+static int change_to_directory (), cd_to_string ();
+
+$BUILTIN cd
+$FUNCTION cd_builtin
+$SHORT_DOC cd [dir]
+Change the current directory to DIR.  The variable $HOME is the
+default DIR.  The variable $CDPATH defines the search path for
+the directory containing DIR.  Alternative directory names are
+separated by a colon (:).  A null directory name is the same as
+the current directory, i.e. `.'.  If DIR begins with a slash (/),
+then $CDPATH is not used.  If the directory is not found, and the
+shell variable `cdable_vars' exists, then try the word as a variable
+name.  If that variable has a value, then cd to the value of that
+variable.
+$END
+
+/* This builtin is ultimately the way that all user-visible commands should
+   change the current working directory.  It is called by cd_to_string (),
+   so the programming interface is simple, and it handles errors and
+   restrictions properly. */
+int
+cd_builtin (list)
+     WORD_LIST *list;
+{
+  char *dirname;
+
+#if defined (RESTRICTED_SHELL)
+  if (restricted)
+    {
+      builtin_error ("restricted");
+      return (EXECUTION_FAILURE);
+    }
+#endif /* RESTRICTED_SHELL */
+
+  if (list)
+    {
+      char *extract_colon_unit ();
+      char *path_string = get_string_value ("CDPATH");
+      char *path;
+      int path_index = 0, dirlen, pathlen;
+
+      dirname = list->word->word;
+
+      if (path_string && !absolute_pathname (dirname))
+	{
+	  while ((path = extract_colon_unit (path_string, &path_index)))
+	    {
+	      char *dir;
+
+	      if (*path == '~')
+		{
+		  char *te_string = tilde_expand (path);
+
+		  free (path);
+		  path = te_string;
+		}
+
+	      if (!*path)
+		{
+		  free (path);
+		  path = xmalloc (2);
+		  path[0] = '.';	/* by definition. */
+		  path[1] = '\0';
+		}
+
+	      dirlen = strlen (dirname);
+	      pathlen = strlen (path);
+	      dir = xmalloc (2 + dirlen + pathlen);
+	      strcpy (dir, path);
+	      if (path[pathlen - 1] != '/')
+	        {
+	          dir[pathlen++] = '/';
+	          dir[pathlen] = '\0';
+	        }
+	      strcpy (dir + pathlen, dirname);
+	      free (path);
+
+	      if (change_to_directory (dir))
+		{
+		  /* replaces (strncmp (dir, "./", 2) != 0) */
+		  if (dir[0] != '.' || dir[1] != '/')
+		    printf ("%s\n", dir);
+
+		  free (dir);
+		  goto bind_and_exit;
+		}
+	      else
+		free (dir);
+	    }
+	}
+
+      if (!change_to_directory (dirname))
+	{
+	  /* Maybe this is `cd -', equivalent to `cd $OLDPWD' */
+	  if (dirname[0] == '-' && dirname[1] == '\0')
+	    {
+	      char *t = get_string_value ("OLDPWD");
+
+	      if (t && change_to_directory (t))
+		goto bind_and_exit;
+	    }
+
+	  /* If the user requests it, then perhaps this is the name of
+	     a shell variable, whose value contains the directory to
+	     change to.  If that is the case, then change to that
+	     directory. */
+	  if (find_variable ("cdable_vars"))
+	    {
+	      char *t = get_string_value (dirname);
+
+	      if (t && change_to_directory (t))
+		{
+		  printf ("%s\n", t);
+		  goto bind_and_exit;
+		}
+	    }
+
+	  file_error (dirname);
+	  return (EXECUTION_FAILURE);
+	}
+      goto bind_and_exit;
+    }
+  else
+    {
+      dirname = get_string_value ("HOME");
+
+      if (!dirname)
+	return (EXECUTION_FAILURE);
+
+      if (!change_to_directory (dirname))
+	{
+	  file_error (dirname);
+	  return (EXECUTION_FAILURE);
+	}
+
+    bind_and_exit:
+      {
+	char *directory;
+
+	directory = get_working_directory ("cd");
+
+	bind_variable ("OLDPWD", get_string_value ("PWD"));
+	bind_variable ("PWD", directory);
+
+	FREE (directory);
+      }
+      return (EXECUTION_SUCCESS);
+    }
+}
+
+$BUILTIN pwd
+$FUNCTION pwd_builtin
+$SHORT_DOC pwd
+Print the current working directory.
+$END
+
+/* Non-zero means that pwd always give verbatim directory, regardless of
+   symbolic link following. */
+static int verbatim_pwd;
+
+/* Print the name of the current working directory. */
+pwd_builtin (list)
+     WORD_LIST *list;
+{
+  char *directory, *s;
+
+#if 0
+  no_args (list);
+#else
+  verbatim_pwd = no_symbolic_links;
+  if (list && (s = list->word->word) && s[0] == '-' && s[1] == 'P' && !s[2])
+    verbatim_pwd = 1;
+#endif
+
+  if (verbatim_pwd)
+    {
+      char *buffer = xmalloc (MAXPATHLEN);
+      directory = getwd (buffer);
+
+      if (!directory)
+	{
+	  builtin_error ("%s", buffer);
+	  free (buffer);
+	}
+    }
+  else
+    directory = get_working_directory ("pwd");
+
+  if (directory)
+    {
+      printf ("%s\n", directory);
+      fflush (stdout);
+      free (directory);
+      return (EXECUTION_SUCCESS);
+    }
+  else
+    return (EXECUTION_FAILURE);
+}
+
+$BUILTIN pushd
+$FUNCTION pushd_builtin
+$DEPENDS_ON PUSHD_AND_POPD
+$SHORT_DOC pushd [dir | +n | -n]
+Adds a directory to the top of the directory stack, or rotates
+the stack, making the new top of the stack the current working
+directory.  With no arguments, exchanges the top two directories.
+
++n	Rotates the stack so that the Nth directory (counting
+	from the left of the list shown by `dirs') is at the top.
+
+-n	Rotates the stack so that the Nth directory (counting
+	from the right) is at the top.
+
+dir	adds DIR to the directory stack at the top, making it the
+	new current working directory.
+
+You can see the directory stack with the `dirs' command.
+$END
+
+#if defined (PUSHD_AND_POPD)
+/* Some useful commands whose behaviour has been observed in Csh. */
+
+/* The list of remembered directories. */
+static char **pushd_directory_list = (char **)NULL;
+
+/* Number of existing slots in this list. */
+static int directory_list_size = 0;
+
+/* Offset to the end of the list. */
+static int directory_list_offset = 0;
+
+pushd_builtin (list)
+     WORD_LIST *list;
+{
+  char *temp, *current_directory;
+  int j = directory_list_offset - 1;
+  char direction = '+';
+
+  /* If there is no argument list then switch current and
+     top of list. */
+  if (!list)
+    {
+      if (!directory_list_offset)
+	{
+	  builtin_error ("No other directory");
+	  return (EXECUTION_FAILURE);
+	}
+
+      current_directory = get_working_directory ("pushd");
+      if (!current_directory)
+	return (EXECUTION_FAILURE);
+
+      temp = pushd_directory_list[j];
+      pushd_directory_list[j] = current_directory;
+      goto change_to_temp;
+    }
+  else
+    {
+      direction = *(list->word->word);
+      if (direction == '+' || direction == '-')
+	{
+	  int num;
+	  if (1 == sscanf (&(list->word->word)[1], "%d", &num))
+	    {
+	      if (direction == '-')
+		num = directory_list_offset - num;
+
+	      if (num > directory_list_offset || num < 0)
+		{
+		  if (!directory_list_offset)
+		    builtin_error ("Directory stack empty");
+		  else
+		    builtin_error ("Stack contains only %d directories",
+				    directory_list_offset + 1);
+		  return (EXECUTION_FAILURE);
+		}
+	      else
+		{
+		  /* Rotate the stack num times.  Remember, the
+		     current directory acts like it is part of the
+		     stack. */
+		  temp = get_working_directory ("pushd");
+
+		  if (!num)
+		    goto change_to_temp;
+
+		  do
+		    {
+		      char *top =
+			pushd_directory_list[directory_list_offset - 1];
+
+		      for (j = directory_list_offset - 2; j > -1; j--)
+			pushd_directory_list[j + 1] = pushd_directory_list[j];
+
+		      pushd_directory_list[j + 1] = temp;
+
+		      temp = top;
+		      num--;
+		    }
+		  while (num);
+
+		  temp = savestring (temp);
+		change_to_temp:
+		  {
+		    int tt = EXECUTION_FAILURE;
+
+		    if (temp)
+		      {
+			tt = cd_to_string (temp);
+			free (temp);
+		      }
+
+		    if ((tt == EXECUTION_SUCCESS))
+		      dirs_builtin ((WORD_LIST *)NULL);
+
+		    return (tt);
+		  }
+		}
+	    }
+	}
+
+      /* Change to the directory in list->word->word.  Save the current
+	 directory on the top of the stack. */
+      current_directory = get_working_directory ("pushd");
+      if (!current_directory)
+	return (EXECUTION_FAILURE);
+
+      if (cd_builtin (list) == EXECUTION_SUCCESS)
+	{
+	  if (directory_list_offset == directory_list_size)
+	    {
+	      pushd_directory_list = (char **)
+		xrealloc (pushd_directory_list,
+			  (directory_list_size += 10) * sizeof (char *));
+	    }
+	  pushd_directory_list[directory_list_offset++] = current_directory;
+
+	  dirs_builtin ((WORD_LIST *)NULL);
+
+	  return (EXECUTION_SUCCESS);
+	}
+      else
+	{
+	  free (current_directory);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+}
+#endif /* PUSHD_AND_POPD */
+
+$BUILTIN dirs
+$FUNCTION dirs_builtin
+$DEPENDS_ON PUSHD_AND_POPD
+$SHORT_DOC dirs [-l]
+Display the list of currently remembered directories.  Directories
+find their way onto the list with the `pushd' command; you can get
+back up through the list with the `popd' command.
+
+The -l flag specifies that `dirs' should not print shorthand versions
+of directories which are relative to your home directory.  This means
+that `~/bin' might be displayed as `/homes/bfox/bin'.
+$END
+
+#if defined (PUSHD_AND_POPD)
+/* Print the current list of directories on the directory stack. */
+dirs_builtin (list)
+     WORD_LIST *list;
+{
+  int i, format, desired_index, index_flag;
+  char *temp, *w;
+
+  format = index_flag = 0;
+  desired_index = -1;
+  /* Maybe do long form or print specific dir stack entry? */
+  while (list)
+    {
+      if (strcmp (list->word->word, "-l") == 0)
+	{
+	  format++;
+	  list = list->next;
+	}
+      else if (*list->word->word == '+' && all_digits (list->word->word + 1))
+	{
+	  w = list->word->word + 1;
+	  index_flag = 1;
+	  i = atoi (w);
+	  /* dirs +0 prints the current working directory. */
+	  if (i == 0)
+	    desired_index = i;
+	  else if (i == directory_list_offset)
+	    {
+	      desired_index = 0;
+	      index_flag = 2;
+	    }
+	  else
+	    desired_index = directory_list_offset - i;
+	  list = list->next;
+	}
+      else if (*list->word->word == '-' && all_digits (list->word->word + 1))
+	{
+	  w = list->word->word + 1;
+	  i = atoi (w);
+	  index_flag = 2;
+	  /* dirs -X where X is directory_list_offset prints the current
+	     working directory. */
+	  if (i == directory_list_offset)
+	    {
+	      index_flag = 1;
+	      desired_index = 0;
+	    }
+	  else
+	    desired_index = i;
+	  list = list->next;
+	}
+      else
+	{
+	  bad_option (list->word->word);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+
+  if (index_flag && (desired_index < 0 || desired_index > directory_list_offset))
+    {
+      if (directory_list_offset == 0)
+	builtin_error ("directory stack empty");
+      else
+	builtin_error ("%s: bad directory stack index", w);
+      return (EXECUTION_FAILURE);
+    }
+
+  /* The first directory printed is always the current working directory. */
+  if (!index_flag || (index_flag == 1 && desired_index == 0))
+    {
+      temp = get_working_directory ("dirs");
+      if (!temp)
+	temp = savestring ("<no directory>");
+      printf ("%s", format ? temp : polite_directory_format (temp));
+      free (temp);
+      if (index_flag)
+	{
+	  putchar ('\n');
+	  return EXECUTION_SUCCESS;
+	}
+    }
+
+#define DIRSTACK_ENTRY(i) \
+	format ? pushd_directory_list[i] \
+	       : polite_directory_format (pushd_directory_list[i])
+
+  /* Now print the requested directory stack entries. */
+  if (index_flag)
+    printf ("%s", DIRSTACK_ENTRY (desired_index));
+  else
+    for (i = (directory_list_offset - 1); i > -1; i--)
+      printf (" %s", DIRSTACK_ENTRY (i));
+
+  putchar ('\n');
+  fflush (stdout);
+  return (EXECUTION_SUCCESS);
+}
+#endif /* PUSHD_AND_POPD */
+
+$BUILTIN popd
+$FUNCTION popd_builtin
+$DEPENDS_ON PUSHD_AND_POPD
+$SHORT_DOC popd [+n | -n]
+Removes entries from the directory stack.  With no arguments,
+removes the top directory from the stack, and cd's to the new
+top directory.
+
++n	removes the Nth entry counting from the left of the list
+	shown by `dirs', starting with zero.  For example: `popd +0'
+	removes the first directory, `popd +1' the second.
+
+-n	removes the Nth entry counting from the right of the list
+	shown by `dirs', starting with zero.  For example: `popd -0'
+	removes the last directory, `popd -1' the next to last.
+
+You can see the directory stack with the `dirs' command.
+$END
+
+#if defined (PUSHD_AND_POPD)
+/* Pop the directory stack, and then change to the new top of the stack.
+   If LIST is non-null it should consist of a word +N or -N, which says
+   what element to delete from the stack.  The default is the top one. */
+popd_builtin (list)
+     WORD_LIST *list;
+{
+  register int i;
+  int which = 0;
+  char direction = '+';
+
+  if (list)
+    {
+      direction = *(list->word->word);
+
+      if ((direction != '+' && direction != '-') ||
+	  (1 != sscanf (&((list->word->word)[1]), "%d", &which)))
+	{
+	  builtin_error ("bad arg `%s'", list->word->word);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+
+  if (which > directory_list_offset || (!directory_list_offset && !which))
+    {
+      if (!directory_list_offset)
+	builtin_error ("Directory stack empty");
+      else
+	builtin_error ("Stack contains only %d directories",
+			directory_list_offset + 1);
+      return (EXECUTION_FAILURE);
+    }
+
+  /* Handle case of no specification, or top of stack specification. */
+  if ((direction == '+' && which == 0) ||
+      (direction == '-' && which == directory_list_offset))
+    {
+      i = cd_to_string (pushd_directory_list[directory_list_offset - 1]);
+      if (i != EXECUTION_SUCCESS)
+	return (i);
+      free (pushd_directory_list[--directory_list_offset]);
+    }
+  else
+    {
+      /* Since an offset other than the top directory was specified,
+	 remove that directory from the list and shift the remainder
+	 of the list into place. */
+
+      if (direction == '+')
+	i = directory_list_offset - which;
+      else
+	i = which;
+
+      free (pushd_directory_list[i]);
+      directory_list_offset--;
+
+      /* Shift the remainder of the list into place. */
+      for (; i < directory_list_offset; i++)
+	pushd_directory_list[i] = pushd_directory_list[i + 1];
+    }
+
+  dirs_builtin ((WORD_LIST *)NULL);
+
+  return (EXECUTION_SUCCESS);
+}
+#endif /* PUSHD_AND_POPD */
+
+/* Do the work of changing to the directory NEWDIR.  Handle symbolic
+   link following, etc. */
+
+static int
+change_to_directory (newdir)
+     char *newdir;
+{
+  char *t;
+
+  if (!no_symbolic_links)
+    {
+      int chdir_return = 0;
+      char *tdir = (char *)NULL;
+
+      if (!the_current_working_directory)
+	{
+	  t = get_working_directory ("cd_links");
+	  FREE (t);
+	}
+
+      if (the_current_working_directory)
+	t = make_absolute (newdir, the_current_working_directory);
+      else
+	t = savestring (newdir);
+
+      /* TDIR is the canonicalized absolute pathname of the NEWDIR. */
+      tdir = canonicalize_pathname (t);
+
+      /* Use the canonicalized version of NEWDIR, or, if canonicalization
+	 failed, use the non-canonical form. */
+      if (tdir && *tdir)
+	free (t);
+      else
+	{
+	  FREE (tdir);
+
+	  tdir = t;
+	}
+
+      if (chdir (tdir) < 0)
+	{
+	  int err;
+
+	  chdir_return = 0;
+	  free (tdir);
+
+	  err = errno;
+
+	  /* We failed changing to the canonicalized directory name.  Try
+	     what the user passed verbatim.  If we succeed, reinitialize
+	     the_current_working_directory. */
+	  if (chdir (newdir) == 0)
+	    {
+	      chdir_return = 1;
+	      if (the_current_working_directory)
+		{
+		  free (the_current_working_directory);
+		  the_current_working_directory = (char *)NULL;
+		}
+
+	      tdir = get_working_directory ("cd");
+	      FREE (tdir);
+	    }
+	  else
+	    errno = err;
+	}
+      else
+	{
+	  chdir_return = 1;
+
+	  FREE (the_current_working_directory);
+	  the_current_working_directory = tdir;
+	}
+
+      return (chdir_return);
+    }
+  else
+    {
+      if (chdir (newdir) < 0)
+	return (0);
+      else
+	return (1);
+    }
+}
+
+/* Switch to the directory in NAME.  This uses the cd_builtin to do the work,
+   so if the result is EXECUTION_FAILURE then an error message has already
+   been printed. */
+static int
+cd_to_string (name)
+     char *name;
+{
+  WORD_LIST *tlist = make_word_list (make_word (name), NULL);
+  int result = (cd_builtin (tlist));
+  dispose_words (tlist);
+  return (result);
+}

builtins/colon.def

@@ -0,0 +1,37 @@
+This file is colon.def, from which is created colon.c.
+It implements the builtin ":" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES colon.c
+
+$BUILTIN :
+$DOCNAME colon_builtin
+$FUNCTION colon_builtin
+$SHORT_DOC :
+No effect; the command does nothing.  A zero exit code is returned.
+$END
+
+/* Do nothing.  This command is a no-op. */
+int
+colon_builtin (ignore)
+     char *ignore;
+{
+  return (0);
+}

builtins/command.def

@@ -0,0 +1,177 @@
+This file is command.def, from which is created command.c.
+It implements the builtin "command" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES command.c
+
+$BUILTIN command
+$FUNCTION command_builtin
+$SHORT_DOC command [-pVv] [command [arg ...]]
+Runs COMMAND with ARGS ignoring shell functions.  If you have a shell
+function called `ls', and you wish to call the command `ls', you can
+say "command ls".  If the -p option is given, a default value is used
+for PATH that is guaranteed to find all of the standard utilities.  If
+the -V or -v option is given, a string is printed describing COMMAND.
+The -V option produces a more verbose description.
+$END
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+#include "bashgetopt.h"
+
+extern int subshell_environment;
+
+static void restore_path ();
+static char *get_standard_path ();
+
+/* Run the commands mentioned in LIST without paying attention to shell
+   functions. */
+int
+command_builtin (list)
+     WORD_LIST *list;
+{
+  int result, verbose = 0, use_standard_path = 0, opt;
+  char *old_path;
+  
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, "pvV")) != -1)
+    {
+      switch (opt)
+	{
+	case 'p':
+	  use_standard_path = 1;
+	  break;
+	case 'V':
+	  verbose = 2;
+	  break;
+	case 'v':
+	  verbose = 4;
+	  break;
+
+	default:
+	  report_bad_option ();
+	  builtin_error ("usage: command [-pvV] [command [arg...]]");
+	  return (EX_USAGE);
+	}
+    }
+  list = loptend;
+
+  if (!list)
+    return (EXECUTION_SUCCESS);
+
+  if (verbose)
+    {
+      int found, any_found = 0;
+
+      while (list)
+	{
+
+	  found = describe_command (list->word->word, verbose, 0);
+
+	  if (!found)
+	    builtin_error ("%s: not found", list->word->word);
+
+	  any_found += found;
+	  list = list->next;
+	}
+      return (any_found ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
+    }
+
+  begin_unwind_frame ("command_builtin");
+
+  /* We don't want this to be reparsed (consider command echo 'foo &'), so
+     just make a simple_command structure and call execute_command with it. */
+  {
+    COMMAND *command;
+
+    if (use_standard_path)
+      {
+	char *standard_path;
+
+	old_path = get_string_value ("PATH");
+	if (old_path)
+	  old_path = savestring (old_path);
+	else
+	  old_path = savestring ("");
+	add_unwind_protect ((Function *)restore_path, old_path);
+
+	standard_path = get_standard_path ();
+	bind_variable ("PATH", standard_path);
+	free (standard_path);
+      }
+    command = make_bare_simple_command ();
+    command->value.Simple->words = (WORD_LIST *)copy_word_list (list);
+    command->value.Simple->redirects = (REDIRECT *)NULL;
+    command->flags |= (CMD_NO_FUNCTIONS | CMD_INHIBIT_EXPANSION);
+    command->value.Simple->flags |= (CMD_NO_FUNCTIONS | CMD_INHIBIT_EXPANSION);
+    /* If we're in a subshell, see if we can get away without forking
+       again, since we've already forked to run this builtin. */
+    if (subshell_environment)
+      {
+	command->flags |= CMD_NO_FORK;
+	command->value.Simple->flags |= CMD_NO_FORK;
+      }
+    add_unwind_protect ((char *)dispose_command, command);
+    result = execute_command (command);
+  }
+
+  run_unwind_frame ("command_builtin");
+
+  return (result);
+}
+
+/* Restore the value of the $PATH variable after replacing it when
+   executing `command -p'. */
+static void
+restore_path (var)
+     char *var;
+{
+  bind_variable ("PATH", var);
+  free (var);
+}
+
+/* Return a value for PATH that is guaranteed to find all of the standard
+   utilities.  This uses Posix.2 configuration variables, if present.  It
+   uses a value defined in config.h as a last resort. */
+static char *
+get_standard_path ()
+{
+#if defined (_CS_PATH) && !defined (hpux_7) && !defined (NetBSD)
+  char *p;
+  size_t len;
+
+  len = (size_t)confstr (_CS_PATH, (char *)NULL, (size_t)0);
+  p = xmalloc ((int)len + 2);
+  *p = '\0';
+  confstr (_CS_PATH, p, len);
+  return (p);
+#else /* !_CSPATH || hpux_7 || NetBSD */
+#  if defined (CS_PATH)
+  return (savestring (CS_PATH));
+#  else
+  return (savestring (STANDARD_UTILS_PATH));
+#  endif /* !CS_PATH */
+#endif /* !_CS_PATH || hpux_7 */
+}

builtins/common.c

@@ -0,0 +1,829 @@
+/* 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include "../posixstat.h"
+#if defined (HAVE_VFPRINTF)
+#include <varargs.h>
+#endif /* VFPRINTF */
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+#include "../unwind_prot.h"
+#include "../maxpath.h"
+#include "../jobs.h"
+#include "../builtins.h"
+#include "../input.h"
+#include "../execute_cmd.h"
+#include "hashcom.h"
+#include "common.h"
+#include <tilde/tilde.h>
+
+#if defined (HISTORY)
+#  include "../bashhist.h"
+#endif
+
+extern int no_symbolic_links, interactive, interactive_shell;
+extern int indirection_level, startup_state;
+extern int last_command_exit_value;
+extern int hashing_disabled;
+extern int variable_context;
+extern char *this_command_name, *shell_name;
+extern COMMAND *global_command;
+extern HASH_TABLE *hashed_filenames;
+
+/* Read a numeric arg for this_command_name, the name of the shell builtin
+   that wants it.  LIST is the word list that the arg is to come from. */
+int
+get_numeric_arg (list)
+     WORD_LIST *list;
+{
+  int count = 1;
+
+  if (list)
+    {
+      register char *arg;
+      int sign = 1;
+
+      arg = list->word->word;
+      if (!arg)
+	goto bad_number;
+
+      /* Skip optional leading white space. */
+      while (whitespace (*arg))
+	arg++;
+
+      if (!*arg)
+        goto bad_number;
+
+      /* We allow leading `-' or `+'. */
+      if (*arg == '-' || *arg == '+')
+	{
+	  if (!digit (arg[1]))
+	    goto bad_number;
+
+	  if (*arg == '-')
+	    sign = -1;
+
+	  arg++;
+	}
+
+      for (count = 0; digit (*arg); arg++)
+	count = (count * 10) + digit_value (*arg);
+
+      /* Skip trailing whitespace, if any. */
+      while (whitespace (*arg))
+        arg++;
+
+      if (!*arg)
+        count = count * sign;
+      else
+	{
+  bad_number:
+	  builtin_error ("bad non-numeric arg `%s'", list->word->word);
+	  throw_to_top_level ();
+	}
+      no_args (list->next);
+    }
+  return (count);
+}
+
+/* This is a lot like report_error (), but it is for shell builtins
+   instead of shell control structures, and it won't ever exit the
+   shell. */
+#if defined (HAVE_VFPRINTF)
+void
+builtin_error (va_alist)
+     va_dcl
+{
+  char *format;
+  va_list args;
+
+  if (this_command_name && *this_command_name)
+    fprintf (stderr, "%s: ", this_command_name);
+
+  va_start (args);
+  format = va_arg (args, char *);
+  vfprintf (stderr, format, args);
+  va_end (args);
+  fprintf (stderr, "\n");
+}
+#else /* !HAVE_VFPRINTF */
+void
+builtin_error (format, arg1, arg2, arg3, arg4, arg5)
+     char *format, *arg1, *arg2, *arg3, *arg4, *arg5;
+{
+  if (this_command_name && *this_command_name)
+    fprintf (stderr, "%s: ", this_command_name);
+
+  fprintf (stderr, format, arg1, arg2, arg3, arg4, arg5);
+  fprintf (stderr, "\n");
+  fflush (stderr);
+}
+#endif /* !HAVE_VFPRINTF */
+
+/* Remember LIST in $0 ... $9, and REST_OF_ARGS.  If DESTRUCTIVE is
+   non-zero, then discard whatever the existing arguments are, else
+   only discard the ones that are to be replaced. */
+void
+remember_args (list, destructive)
+     WORD_LIST *list;
+     int destructive;
+{
+  register int i;
+
+  for (i = 1; i < 10; i++)
+    {
+      if (destructive && dollar_vars[i])
+	{
+	  free (dollar_vars[i]);
+	  dollar_vars[i] = (char *)NULL;
+	}
+
+      if (list)
+	{
+	  if (!destructive && dollar_vars[i])
+	    free (dollar_vars[i]);
+
+	  dollar_vars[i] = savestring (list->word->word);
+	  list = list->next;
+	}
+    }
+
+  /* If arguments remain, assign them to REST_OF_ARGS.
+     Note that copy_word_list (NULL) returns NULL, and
+     that dispose_words (NULL) does nothing. */
+  if (destructive || list)
+    {
+      dispose_words (rest_of_args);
+      rest_of_args = copy_word_list (list);
+    }
+
+  if (destructive)
+    set_dollar_vars_changed ();
+}
+
+/* Return if LIST is NULL else barf and jump to top_level. */
+void
+no_args (list)
+     WORD_LIST *list;
+{
+  if (list)
+    {
+      builtin_error ("extra arguments");
+      longjmp (top_level, DISCARD);
+    }
+}
+
+/* Return the octal number parsed from STRING, or -1 to indicate
+   that the string contained a bad number. */
+int
+read_octal (string)
+     char *string;
+{
+  int result = 0;
+  int digits = 0;
+
+  while (*string && *string >= '0' && *string < '8')
+    {
+      digits++;
+      result = (result * 8) + *string++ - '0';
+    }
+
+  if (!digits || result > 0777 || *string)
+    result = -1;
+
+  return (result);
+}
+
+/* Temporary static. */
+static char *dotted_filename = (char *)NULL;
+
+/* Return the full pathname that FILENAME hashes to.  If FILENAME
+   is hashed, but data->check_dot is non-zero, check ./FILENAME
+   and return that if it is executable. */
+char *
+find_hashed_filename (filename)
+     char *filename;
+{
+  register BUCKET_CONTENTS *item;
+
+  if (hashing_disabled)
+    return ((char *)NULL);
+
+  item = find_hash_item (filename, hashed_filenames);
+
+  if (item)
+    {
+      /* If this filename is hashed, but `.' comes before it in the path,
+	 then see if `./filename' is an executable. */
+      if (pathdata(item)->check_dot)
+	{
+	  if (dotted_filename)
+	    free (dotted_filename);
+
+	  dotted_filename = (char *)xmalloc (3 + strlen (filename));
+	  strcpy (dotted_filename, "./");
+	  strcat (dotted_filename, filename);
+
+	  if (executable_file (dotted_filename))
+	    return (dotted_filename);
+
+	  /* Watch out.  If this file was hashed to "./filename", and
+	     "./filename" is not executable, then return NULL. */
+
+	  /* Since we already know "./filename" is not executable, what
+	     we're really interested in is whether or not the `path'
+	     portion of the hashed filename is equivalent to the current
+	     directory, but only if it starts with a `.'.  (This catches
+	     ./. and so on.)  same_file () is in execute_cmd.c; it tests
+	     general Unix file equivalence -- same device and inode. */
+	  {
+	    char *path = pathdata (item)->path;
+
+	    if (*path == '.')
+	      {
+		int same = 0;
+		char *tail;
+
+		tail = (char *) strrchr (path, '/');
+
+		if (tail)
+		  {
+		    *tail = '\0';
+		    same = same_file
+		      (".", path, (struct stat *)NULL, (struct stat *)NULL);
+		    *tail = '/';
+		  }
+		if (same)
+		  return ((char *)NULL);
+	      }
+	  }
+	}
+      return (pathdata (item)->path);
+    }
+  else
+    return ((char *)NULL);
+}
+
+/* Remove FILENAME from the table of hashed commands. */
+void
+remove_hashed_filename (filename)
+     char *filename;
+{
+  register BUCKET_CONTENTS *item;
+
+  if (hashing_disabled)
+    return;
+
+  item = remove_hash_item (filename, hashed_filenames);
+  if (item)
+    {
+      if (item->data)
+        {
+	  free (pathdata(item)->path);
+	  free (item->data);
+        }
+      if (item->key)
+	free (item->key);
+      free (item);
+    }
+}
+
+/* **************************************************************** */
+/*								    */
+/*		    Pushing and Popping a Context		    */
+/*								    */
+/* **************************************************************** */
+
+static WORD_LIST **dollar_arg_stack = (WORD_LIST **)NULL;
+static int dollar_arg_stack_slots = 0;
+static int dollar_arg_stack_index = 0;
+
+void
+push_context ()
+{
+  push_dollar_vars ();
+  variable_context++;
+}
+
+void
+pop_context ()
+{
+  pop_dollar_vars ();
+  kill_all_local_variables ();
+  variable_context--;
+}
+
+/* Save the existing positional parameters on a stack. */
+void
+push_dollar_vars ()
+{
+  if (dollar_arg_stack_index + 2 > dollar_arg_stack_slots)
+    {
+      dollar_arg_stack = (WORD_LIST **)
+	xrealloc (dollar_arg_stack, (dollar_arg_stack_slots += 10)
+		  * sizeof (WORD_LIST **));
+    }
+  dollar_arg_stack[dollar_arg_stack_index] = list_rest_of_args ();
+  dollar_arg_stack[++dollar_arg_stack_index] = (WORD_LIST *)NULL;
+}
+
+/* Restore the positional parameters from our stack. */
+void
+pop_dollar_vars ()
+{
+  if (!dollar_arg_stack || !dollar_arg_stack_index)
+    return;
+
+  remember_args (dollar_arg_stack[--dollar_arg_stack_index], 1);
+  dispose_words (dollar_arg_stack[dollar_arg_stack_index]);
+  dollar_arg_stack[dollar_arg_stack_index] = (WORD_LIST *)NULL;
+}
+
+void
+dispose_saved_dollar_vars ()
+{
+  if (!dollar_arg_stack || !dollar_arg_stack_index)
+    return;
+
+  dispose_words (dollar_arg_stack[dollar_arg_stack_index]);
+  dollar_arg_stack[dollar_arg_stack_index] = (WORD_LIST *)NULL;
+}
+
+static int changed_dollar_vars = 0;
+
+/* Have the dollar variables been reset to new values since we last
+   checked? */
+dollar_vars_changed ()
+{
+  return (changed_dollar_vars);
+}
+
+void
+set_dollar_vars_unchanged ()
+{
+  changed_dollar_vars = 0;
+}
+
+void
+set_dollar_vars_changed ()
+{
+  changed_dollar_vars  = 1;
+}
+
+/* Function called when one of the builtin commands detects a bad
+   option. */
+void
+bad_option (s)
+     char *s;
+{
+  builtin_error ("unknown option: %s", s);
+}
+
+/* Return a consed string which is the current working directory.
+   FOR_WHOM is the name of the caller for error printing.  */
+char *the_current_working_directory = (char *)NULL;
+
+char *
+get_working_directory (for_whom)
+     char *for_whom;
+{
+  if (no_symbolic_links)
+    {
+      if (the_current_working_directory)
+	free (the_current_working_directory);
+
+      the_current_working_directory = (char *)NULL;
+    }
+
+  if (!the_current_working_directory)
+    {
+      char *directory;
+
+      the_current_working_directory = xmalloc (MAXPATHLEN);
+      directory = getwd (the_current_working_directory);
+      if (!directory)
+	{
+	  if (for_whom && *for_whom)
+	    fprintf (stderr, "%s: ", for_whom);
+	  else
+	    fprintf (stderr, "%s: ", get_name_for_error ());
+
+	  fprintf (stderr, "could not get current directory: %s\n",
+		   the_current_working_directory);
+
+	  free (the_current_working_directory);
+	  the_current_working_directory = (char *)NULL;
+	  return (char *)NULL;
+	}
+    }
+
+  return (savestring (the_current_working_directory));
+}
+
+/* Make NAME our internal idea of the current working directory. */
+void
+set_working_directory (name)
+     char *name;
+{
+  if (the_current_working_directory)
+    free (the_current_working_directory);
+
+  the_current_working_directory = savestring (name);
+}
+
+#if defined (JOB_CONTROL)
+/* Return the job spec found in LIST. */
+get_job_spec (list)
+     WORD_LIST *list;
+{
+  register char *word;
+  int job = NO_JOB;
+  int substring = 0;
+
+  if (!list)
+    return (current_job);
+
+  word = list->word->word;
+
+  if (!*word)
+    return (current_job);
+
+  if (*word == '%')
+    word++;
+
+  if (digit (*word) && (sscanf (word, "%d", &job) == 1))
+    return (job - 1);
+
+  switch (*word)
+    {
+    case 0:
+    case '%':
+    case '+':
+      return (current_job);
+
+    case '-':
+      return (previous_job);
+
+    case '?':			/* Substring search requested. */
+      substring++;
+      word++;
+      goto find_string;
+
+    default:
+    find_string:
+      {
+	register int i, wl = strlen (word);
+	for (i = 0; i < job_slots; i++)
+	  {
+	    if (jobs[i])
+	      {
+		register PROCESS *p = jobs[i]->pipe;
+		do
+		  {
+		    if ((substring && strindex (p->command, word)) ||
+			(strncmp (p->command, word, wl) == 0))
+		      if (job != NO_JOB)
+			{
+			  builtin_error ("ambigious job spec: %s", word);
+			  return (DUP_JOB);
+			}
+		      else
+			job = i;
+
+		    p = p->next;
+		  }
+		while (p != jobs[i]->pipe);
+	      }
+	  }
+	return (job);
+      }
+    }
+}
+#endif /* JOB_CONTROL */
+
+int parse_and_execute_level = 0;
+
+/* How to force parse_and_execute () to clean up after itself. */
+void
+parse_and_execute_cleanup ()
+{
+  run_unwind_frame ("parse_and_execute_top");
+}
+
+/* Parse and execute the commands in STRING.  Returns whatever
+   execute_command () returns.  This frees STRING.  INTERACT is
+   the new value for `interactive' while the commands are being
+   executed.  A value of -1 means don't change it. */
+int
+parse_and_execute (string, from_file, interact)
+     char *string;
+     char *from_file;
+     int interact;
+{
+  int last_result = EXECUTION_SUCCESS;
+  int code = 0, jump_to_top_level = 0;
+  char *orig_string = string;
+
+  /* Unwind protect this invocation of parse_and_execute (). */
+  begin_unwind_frame ("parse_and_execute_top");
+  unwind_protect_int (parse_and_execute_level);
+  unwind_protect_jmp_buf (top_level);
+  unwind_protect_int (indirection_level);
+  if (interact != -1 && interactive != interact)
+    unwind_protect_int (interactive);
+
+#if defined (HISTORY)
+  if (interactive_shell)
+    {
+      unwind_protect_int (remember_on_history);
+#  if defined (BANG_HISTORY)
+      unwind_protect_int (history_expansion_inhibited);
+#  endif /* BANG_HISTORY */
+    }
+#endif /* HISTORY */
+
+  add_unwind_protect (pop_stream, (char *)NULL);
+  if (orig_string)
+    add_unwind_protect (xfree, orig_string);
+  end_unwind_frame ();
+
+  parse_and_execute_level++;
+  push_stream ();
+  indirection_level++;
+  if (interact != -1)
+    interactive = interact;
+
+#if defined (HISTORY)
+  /* We don't remember text read by the shell this way on
+     the history list, and we don't use !$ in shell scripts. */
+  remember_on_history = 0;
+#  if defined (BANG_HISTORY)
+  history_expansion_inhibited = 1;
+#  endif /* BANG_HISTORY */
+#endif /* HISTORY */
+
+  with_input_from_string (string, from_file);
+  {
+    COMMAND *command;
+
+    while (*(bash_input.location.string))
+      {
+	if (interrupt_state)
+	  {
+	    last_result = EXECUTION_FAILURE;
+	    break;
+	  }
+
+	/* Provide a location for functions which `longjmp (top_level)' to
+	   jump to.  This prevents errors in substitution from restarting
+	   the reader loop directly, for example. */
+	code = setjmp (top_level);
+
+	if (code)
+	  {
+	    jump_to_top_level = 0;
+	    switch (code)
+	      {
+	      case FORCE_EOF:
+	      case EXITPROG:
+		run_unwind_frame ("pe_dispose");
+		/* Remember to call longjmp (top_level) after the old
+		   value for it is restored. */
+		jump_to_top_level = 1;
+		goto out;
+
+	      case DISCARD:
+	        dispose_command (command);
+		run_unwind_frame ("pe_dispose");
+		last_command_exit_value = 1;
+		continue;
+
+	      default:
+		programming_error ("bad jump to top_level: %d", code);
+		break;
+	      }
+	  }
+	  
+	if (parse_command () == 0)
+	  {
+	    if ((command = global_command) != (COMMAND *)NULL)
+	      {
+		struct fd_bitmap *bitmap;
+
+		bitmap = new_fd_bitmap (FD_BITMAP_SIZE);
+		begin_unwind_frame ("pe_dispose");
+		add_unwind_protect (dispose_fd_bitmap, bitmap);
+
+		global_command = (COMMAND *)NULL;
+
+#if defined (ONESHOT)
+	        if (startup_state == 2 && *bash_input.location.string == '\0' &&
+		    command->type == cm_simple && !command->redirects &&
+		    !command->value.Simple->redirects)
+		  {
+		    command->flags |= CMD_NO_FORK;
+		    command->value.Simple->flags |= CMD_NO_FORK;
+		  }
+#endif /* ONESHOT */
+    
+		last_result = execute_command_internal
+		    (command, 0, NO_PIPE, NO_PIPE, bitmap);
+
+		dispose_command (command);
+		run_unwind_frame ("pe_dispose");
+	      }
+	  }
+	else
+	  {
+	    last_result = EXECUTION_FAILURE;
+
+	    /* Since we are shell compatible, syntax errors in a script
+	       abort the execution of the script.  Right? */
+	    break;
+	  }
+      }
+  }
+
+ out:
+
+  run_unwind_frame ("parse_and_execute_top");
+
+  if (interrupt_state && parse_and_execute_level == 0)
+    {
+      /* An interrupt during non-interactive execution in an
+         interactive shell (e.g. via $PROMPT_COMMAND) should
+         not cause the shell to exit. */
+      interactive = interactive_shell;
+      throw_to_top_level ();
+    }
+
+  if (jump_to_top_level)
+    longjmp (top_level, code);
+
+  return (last_result);
+}
+
+/* Return the address of the builtin named NAME.
+   DISABLED_OKAY means find it even if the builtin is disabled. */
+static Function *
+builtin_address_internal (name, disabled_okay)
+     char *name;
+     int disabled_okay;
+{
+  int hi, lo, mid, j;
+
+  hi = num_shell_builtins - 1;
+  lo = 0;
+
+  while (lo <= hi)
+    {
+      mid = (lo + hi) / 2;
+
+      j = shell_builtins[mid].name[0] - name[0];
+
+      if (j == 0)
+	j = strcmp (shell_builtins[mid].name, name);
+
+      if (j == 0)
+	{
+	  /* It must have a function pointer.  It must be enabled, or we
+	     must have explicitly allowed disabled functions to be found. */
+	  if (shell_builtins[mid].function &&
+	      ((shell_builtins[mid].flags & BUILTIN_ENABLED) || disabled_okay))
+	    return (shell_builtins[mid].function);
+	  else
+	    return ((Function *)NULL);
+	}
+      if (j > 0)
+	hi = mid - 1;
+      else
+	lo = mid + 1;
+    }
+  return ((Function *)NULL);
+}
+
+/* Perform a binary search and return the address of the builtin function
+   whose name is NAME.  If the function couldn't be found, or the builtin
+   is disabled or has no function associated with it, return NULL. */
+Function *
+find_shell_builtin (name)
+	char *name;
+{
+  return (builtin_address_internal (name, 0));
+}
+
+/* Return the address of builtin with NAME, irregardless of its state of
+   enableness. */
+Function *
+builtin_address (name)
+     char *name;
+{
+  return (builtin_address_internal (name, 1));
+}
+
+static int
+shell_builtin_compare (sbp1, sbp2)
+     struct builtin *sbp1, *sbp2;
+{
+  int result;
+
+  if ((result = sbp1->name[0] - sbp2->name[0]) == 0)
+    result = strcmp (sbp1->name, sbp2->name);
+
+  return (result);
+}
+
+/* Sort the table of shell builtins so that the binary search will work
+   in find_shell_builtin. */
+void
+initialize_shell_builtins ()
+{
+  qsort (shell_builtins, num_shell_builtins, sizeof (struct builtin),
+    shell_builtin_compare);
+}
+
+/* Return a new string which is the quoted version of STRING.  This is used
+   by alias and trap. */
+char *
+single_quote (string)
+     char *string;
+{
+  register int i, j, c;
+  char *result;
+
+  result = (char *)xmalloc (3 + (3 * strlen (string)));
+
+  result[0] = '\'';
+
+  for (i = 0, j = 1; string && (c = string[i]); i++)
+    {
+      result[j++] = c;
+
+      if (c == '\'')
+	{
+	  result[j++] = '\\';	/* insert escaped single quote */
+	  result[j++] = '\'';
+	  result[j++] = '\'';	/* start new quoted string */
+	}
+    }
+
+  result[j++] = '\'';
+  result[j] = '\0';
+
+  return (result);
+}
+
+char *
+double_quote (string)
+     char *string;
+{
+  register int i, j, c;
+  char *result;
+
+  result = (char *)xmalloc (3 + (3 * strlen (string)));
+
+  result[0] = '"';
+
+  for (i = 0, j = 1; string && (c = string[i]); i++)
+    {
+      switch (c)
+        {
+	case '"':
+	case '$':
+	case '`':
+	case '\\':
+	  result[j++] = '\\';
+	default:
+	  result[j++] = c;
+	  break;
+        }
+    }
+
+  result[j++] = '"';
+  result[j] = '\0';
+
+  return (result);
+}

builtins/common.h

@@ -0,0 +1,69 @@
+/* common.h -- extern declarations for functions defined in common.c. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if  !defined (__COMMON_H)
+#  define __COMMON_H
+
+#define ISOPTION(s, c)	(s[0] == '-' && !s[2] && s[1] == c)
+
+extern void builtin_error ();
+extern void bad_option ();
+
+extern int get_numeric_arg ();
+
+extern void remember_args ();
+
+extern void no_args ();
+
+extern int read_octal ();
+
+extern char *find_hashed_filename ();
+extern void remove_hashed_filename ();
+extern void remember_filename ();
+
+extern void push_context (), pop_context ();
+extern void push_dollar_vars (), pop_dollar_vars ();
+extern void dispose_saved_dollar_vars ();
+extern int dollar_vars_changed ();
+extern void set_dollar_vars_unchanged (), set_dollar_vars_changed ();
+
+/* Keeps track of the current working directory. */
+extern char *the_current_working_directory;
+extern char *get_working_directory ();
+extern void set_working_directory ();
+
+#if defined (JOB_CONTROL)
+extern int get_job_spec ();
+#endif
+
+extern int parse_and_execute ();
+extern void parse_and_execute_cleanup ();
+
+extern void initialize_shell_builtins ();
+
+/* It's OK to declare a function as returning a Function * without
+   providing a definition of what a `Function' is. */
+extern Function *find_shell_builtin ();
+extern Function *builtin_address ();
+
+extern char *single_quote ();
+extern char *double_quote ();
+
+#endif /* !__COMMON_H */

builtins/declare.def

@@ -0,0 +1,290 @@
+This file is declare.def, from which is created declare.c.
+It implements the builtins "declare" and "local" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES declare.c
+
+$BUILTIN declare
+$FUNCTION declare_builtin
+$SHORT_DOC declare [-[frxi]] name[=value] ...
+Declare variables and/or give them attributes.  If no NAMEs are
+given, then display the values of variables instead.
+
+The flags are:
+
+  -f	to select from among function names only,
+  -r	to make NAMEs readonly,
+  -x	to make NAMEs export,
+  -i	to make NAMEs have the `integer' attribute set.
+
+Variables with the integer attribute have arithmetic evaluation (see
+`let') done when the variable is assigned to.
+
+Using `+' instead of `-' turns off the given attribute instead.  When
+used in a function, makes NAMEs local, as with the `local' command.
+$END
+
+$BUILTIN typeset
+$FUNCTION declare_builtin
+$SHORT_DOC typeset [-[frxi]] name[=value] ...
+Obsolete.  See `declare'.
+$END
+
+#include <stdio.h>
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+
+extern int variable_context, array_needs_making;
+
+static int declare_internal ();
+
+/* Declare or change variable attributes. */
+int
+declare_builtin (list)
+     register WORD_LIST *list;
+{
+  return (declare_internal (list, 0));
+}
+
+$BUILTIN local
+$FUNCTION local_builtin
+$SHORT_DOC local name[=value] ...
+Create a local variable called NAME, and give it VALUE.  LOCAL
+can only be used within a function; it makes the variable NAME
+have a visible scope restricted to that function and its children.
+$END
+int
+local_builtin (list)
+     register WORD_LIST *list;
+{
+  if (variable_context)
+    return (declare_internal (list, 1));
+  else
+    {
+      builtin_error ("Can only be used in a function");
+      return (EXECUTION_FAILURE);
+    }
+}
+
+/* The workhorse function. */
+static int
+declare_internal (list, local_var)
+     register WORD_LIST *list;
+     int local_var;
+{
+  int flags_on = 0, flags_off = 0;
+  int any_failed = 0;
+
+  while (list)
+    {
+      register char *t = list->word->word;
+      int *flags;
+
+      if (t[0] == '-' && t[1] == '-' && t[2] == '\0')
+	{
+	  list = list->next;
+	  break;
+	}
+
+      if (*t != '+' && *t != '-')
+	break;
+
+      if (*t == '+')
+	flags = &flags_off;
+      else
+	flags = &flags_on;
+
+      t++;
+
+      while (*t)
+	{
+	  if (*t == 'f')
+	    *flags |= att_function, t++;
+	  else if (*t == 'x')
+	    *flags |= att_exported, t++, array_needs_making = 1;
+	  else if (*t == 'r')
+	    *flags |= att_readonly, t++;
+	  else if (*t == 'i')
+	    *flags |= att_integer, t++;
+	  else
+	    {
+	      builtin_error ("unknown option: `-%c'", *t);
+	      return (EX_USAGE);
+	    }
+	}
+
+      list = list->next;
+    }
+
+  /* If there are no more arguments left, then we just want to show
+     some variables. */
+  if (!list)
+    {
+      /* Show local variables defined at this context level if this is
+	 the `local' builtin. */
+      if (local_var)
+	{
+	  register SHELL_VAR **vlist;
+	  register int i;
+
+	  vlist = map_over (variable_in_context, shell_variables);
+
+	  if (vlist)
+	    {
+	      for (i = 0; vlist[i]; i++)
+		print_assignment (vlist[i]);
+
+	      free (vlist);
+	    }
+	}
+      else
+	{
+	  if (!flags_on)
+	    set_builtin ((WORD_LIST *)NULL);
+	  else
+	    set_or_show_attributes ((WORD_LIST *)NULL, flags_on);
+	}
+
+      fflush (stdout);
+      return (EXECUTION_SUCCESS);
+    }
+
+#define NEXT_VARIABLE() free (name); list = list->next; continue
+
+  /* There are arguments left, so we are making variables. */
+  while (list)
+    {
+      char *value, *name = savestring (list->word->word);
+      int offset = assignment (name);
+
+      if (offset)
+	{
+	  name[offset] = '\0';
+	  value = name + offset + 1;
+	}
+      else
+	value = "";
+
+      if (legal_identifier (name) == 0)
+	{
+	  builtin_error ("%s: not a legal variable name", name);
+	  any_failed++;
+	  NEXT_VARIABLE ();
+	}
+
+      /* If VARIABLE_CONTEXT has a non-zero value, then we are executing
+	 inside of a function.  This means we should make local variables,
+	 not global ones. */
+
+      if (variable_context)
+	make_local_variable (name);
+
+      /* If we are declaring a function, then complain about it in some way.
+	 We don't let people make functions by saying `typeset -f foo=bar'. */
+
+      /* There should be a way, however, to let people look at a particular
+	 function definition by saying `typeset -f foo'. */
+
+      if (flags_on & att_function)
+	{
+	  if (offset)
+	    {
+	      builtin_error ("Can't use `-f' to make functions");
+	      return (EXECUTION_FAILURE);
+	    }
+	  else
+	    {
+	      SHELL_VAR *find_function (), *funvar;
+
+	      funvar = find_function (name);
+
+	      if (funvar)
+		{
+		  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++;
+	      NEXT_VARIABLE ();
+	    }
+	}
+      else
+	{
+	  SHELL_VAR *var;
+
+	  var = find_variable (name);
+
+	  if (!var)
+	    var = bind_variable (name, "");
+
+	  if (readonly_p (var) && (flags_off & att_readonly))
+	    {
+	      builtin_error ("%s: readonly variable", name);
+	      any_failed++;
+	      NEXT_VARIABLE ();
+	    }
+
+	  var->attributes |= flags_on;
+	  var->attributes &= ~flags_off;
+
+	  if (offset)
+	    {
+	      free (var->value);
+	      if (integer_p (var))
+		{
+		  long val, evalexp ();
+		  char *itos ();
+
+		  val = evalexp (value);
+		  var->value = itos ((int)val);
+		}
+	      else
+		var->value = savestring (value);
+	    }
+	}
+
+      stupidly_hack_special_variables (name);
+
+      NEXT_VARIABLE ();
+    }
+  return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
+}

builtins/echo.def

@@ -0,0 +1,168 @@
+This file is echo.def, from which is created echo.c.
+It implements the builtin "echo" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES echo.c
+#include <stdio.h>
+#include "../shell.h"
+
+$BUILTIN echo
+$FUNCTION echo_builtin
+$DEPENDS_ON V9_ECHO
+$SHORT_DOC echo [-neE] [arg ...]
+Output the ARGs.  If -n is specified, the trailing newline is
+suppressed.  If the -e option is given, interpretation of the
+following backslash-escaped characters is turned on:
+	\a	alert (bell)
+	\b	backspace
+	\c	suppress trailing newline
+	\f	form feed
+	\n	new line
+	\r	carriage return
+	\t	horizontal tab
+	\v	vertical tab
+	\\	backslash
+	\num	the character whose ASCII code is NUM (octal).
+
+You can explicitly turn off the interpretation of the above characters
+with the -E option.
+$END
+
+$BUILTIN echo
+$FUNCTION echo_builtin
+$DEPENDS_ON !V9_ECHO
+$SHORT_DOC echo [-n] [arg ...]
+Output the ARGs.  If -n is specified, the trailing newline is suppressed.
+$END
+
+#if defined (V9_ECHO)
+#  define VALID_ECHO_OPTIONS "neE"
+#else /* !V9_ECHO */
+#  define VALID_ECHO_OPTIONS "n"
+#endif /* !V9_ECHO */
+
+/* Print the words in LIST to standard output.  If the first word is
+   `-n', then don't print a trailing newline.  We also support the
+   echo syntax from Version 9 unix systems. */
+echo_builtin (list)
+     WORD_LIST *list;
+{
+  int display_return = 1, do_v9 = 0;
+
+#if defined (DEFAULT_ECHO_TO_USG)
+/* System V machines already have a /bin/sh with a v9 behaviour.  We
+   give Bash the identical behaviour for these machines so that the
+   existing system shells won't barf. */
+  do_v9 = 1;
+#endif /* DEFAULT_ECHO_TO_USG */
+
+  while (list && list->word->word[0] == '-')
+    {
+      register char *temp;
+      register int i;
+
+      /* If it appears that we are handling options, then make sure that
+	 all of the options specified are actually valid.  Otherwise, the
+	 string should just be echoed. */
+      temp = &(list->word->word[1]);
+
+      for (i = 0; temp[i]; i++)
+	{
+	  if (strchr (VALID_ECHO_OPTIONS, temp[i]) == 0)
+	    goto just_echo;
+	}
+
+      if (!*temp)
+	goto just_echo;
+
+      /* All of the options in TEMP are valid options to ECHO.
+	 Handle them. */
+      while (*temp)
+	{
+	  if (*temp == 'n')
+	    display_return = 0;
+#if defined (V9_ECHO)
+	  else if (*temp == 'e')
+	    do_v9 = 1;
+	  else if (*temp == 'E')
+	    do_v9 = 0;
+#endif /* V9_ECHO */
+	  else
+	    goto just_echo;
+
+	  temp++;
+	}
+      list = list->next;
+    }
+
+just_echo:
+
+  if (list)
+    {
+#if defined (V9_ECHO)
+      if (do_v9)
+	{
+	  while (list)
+	    {
+	      register char *s = list->word->word;
+	      register int c;
+
+	      while (c = *s++)
+		{
+		  if (c == '\\' && *s)
+		    {
+		      switch (c = *s++)
+			{
+			case 'a': c = '\007'; break;
+			case 'b': c = '\b'; break;
+			case 'c': display_return = 0; continue;
+			case 'f': c = '\f'; break;
+			case 'n': c = '\n'; break;
+			case 'r': c = '\r'; break;
+			case 't': c = '\t'; break;
+			case 'v': c = (int) 0x0B; break;
+			case '0': case '1': case '2': case '3':
+			case '4': case '5': case '6': case '7':
+			  c -= '0';
+			  if (*s >= '0' && *s <= '7')
+			    c = c * 8 + (*s++ - '0');
+			  if (*s >= '0' && *s <= '7')
+			    c = c * 8 + (*s++ - '0');
+			  break;
+			case '\\': break;
+			default:  putchar ('\\'); break;
+			}
+		    }
+		  putchar(c);
+		}
+	      list = list->next;
+	      if (list)
+		putchar(' ');
+	    }
+	}
+      else
+#endif /* V9_ECHO */
+	print_word_list (list, " ");
+    }
+  if (display_return)
+    printf ("\n");
+  fflush (stdout);
+  return (EXECUTION_SUCCESS);
+}

builtins/enable.def

@@ -0,0 +1,156 @@
+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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES enable.c
+
+$BUILTIN enable
+$FUNCTION enable_builtin
+$SHORT_DOC enable [-n] [name ...]
+Enable and disable builtin shell commands.  This allows
+you to use a disk command which has the same name as a shell
+builtin.  If -n is used, the NAMEs become disabled.  Otherwise
+NAMEs are enabled.  For example, to use the `test' found on your
+path instead of the shell builtin version, you type `enable -n test'.
+$END
+
+#include "../shell.h"
+#include "../builtins.h"
+#include "common.h"
+
+#define ENABLED  1
+#define DISABLED 2
+
+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. */
+enable_builtin (list)
+     WORD_LIST *list;
+{
+  int result = 0, any_failed = 0;
+  int disable_p, all_p;
+
+  disable_p = all_p = 0;
+
+  while (list && list->word->word && list->word->word[0] == '-')
+    {
+      char *arg = list->word->word;
+
+      list = list->next;
+
+      if (ISOPTION (arg, 'n'))
+	disable_p = 1;
+      else if (arg[1] == 'a' && (arg[2] == 0 || strcmp (arg + 2, "ll") == 0))
+	all_p = 1;
+      else if (ISOPTION (arg, '-'))
+        break;
+      else
+	{
+	  bad_option (arg);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+
+  if (!list)
+    {
+      int filter;
+
+      if (all_p)
+	filter = ENABLED | DISABLED;
+      else if (disable_p)
+	filter = DISABLED;
+      else
+	filter = ENABLED;
+
+      list_some_builtins (filter);
+    }
+  else
+    {
+      while (list)
+	{
+	  result = enable_shell_command (list->word->word, disable_p);
+
+	  if (!result)
+	    {
+	      builtin_error ("%s: not a shell builtin", list->word->word);
+	      any_failed++;
+	    }
+	  list = list->next;
+	}
+    }
+  return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
+}
+
+/* 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)
+	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;
+{
+  register int i;
+  int found = 0;
+
+  for (i = 0; i < num_shell_builtins; i++)
+    {
+      if (!shell_builtins[i].function)
+	continue;
+
+      if (STREQ (name, shell_builtins[i].name))
+	{
+	  found++;
+
+	  if (disable_p)
+	    shell_builtins[i].flags &= ~BUILTIN_ENABLED;
+	  else
+	    shell_builtins[i].flags |= BUILTIN_ENABLED;
+	}
+    }
+  return (found);
+}

builtins/eval.def

@@ -0,0 +1,45 @@
+This file is eval.def, from which is created eval.c.
+It implements the builtin "eval" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES eval.c
+
+$BUILTIN eval
+$FUNCTION eval_builtin
+$SHORT_DOC eval [arg ...]
+Read ARGs as input to the shell and execute the resulting command(s).
+$END
+
+#include "../shell.h"
+
+/* Parse the string that these words make, and execute the command found. */
+int
+eval_builtin (list)
+     WORD_LIST *list;
+{
+  int result;
+
+  /* Note that parse_and_execute () frees the string it is passed. */
+  if (list)
+    result = parse_and_execute (string_list (list), "eval", -1);
+  else
+    result = EXECUTION_SUCCESS;
+  return (result);
+}

builtins/exec.def

@@ -0,0 +1,163 @@
+This file is exec.def, from which is created exec.c.
+It implements the builtin "exec" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES exec.c
+
+$BUILTIN exec
+$FUNCTION exec_builtin
+$SHORT_DOC exec [ [-] file [redirection ...]]
+Exec FILE, replacing this shell with the specified program.
+If FILE is not specified, the redirections take effect in this
+shell.  If the first argument is `-', then place a dash in the
+zeroth arg passed to FILE.  If the file cannot be exec'ed and
+the shell is not interactive, then the shell exits, unless the
+shell variable "no_exit_on_failed_exec" exists.
+$END
+
+#include "../shell.h"
+#include <sys/types.h>
+#include "../posixstat.h"
+#include <signal.h>
+#include <errno.h>
+
+#include "../execute_cmd.h"
+#include "common.h"
+#include "../flags.h"
+
+/* Not all systems declare ERRNO in errno.h... and some systems #define it! */
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+extern int interactive, subshell_environment;
+extern REDIRECT *redirection_undo_list;
+
+int
+exec_builtin (list)
+     WORD_LIST *list;
+{
+  int exit_value = EXECUTION_FAILURE;
+
+  maybe_make_export_env ();
+
+  /* First, let the redirections remain. */
+  dispose_redirects (redirection_undo_list);
+  redirection_undo_list = (REDIRECT *)NULL;
+
+  if (!list)
+    return (EXECUTION_SUCCESS);
+  else
+    {
+      /* Otherwise, execve the new command with args. */
+      char *command, **args;
+      int dash_name = 0;
+
+      if (list->word->word[0] == '-' && !list->word->word[1])
+	{
+	  /* The user would like to exec this command as if it was a
+	     login command.  Do so. */
+	  list = list->next;
+	  dash_name++;
+	}
+
+      if (!list)
+	return (EXECUTION_SUCCESS);
+
+#if defined (RESTRICTED_SHELL)
+      if (restricted)
+	{
+	  builtin_error ("restricted");
+	  return (EXECUTION_FAILURE);
+	}
+#endif /* RESTRICTED_SHELL */
+
+      args = make_word_array (list);
+
+      /* A command with a slash anywhere in its name is not looked up in
+	 the search path. */
+      if (absolute_program (args[0]))
+	command = args[0];
+      else
+	command = find_user_command (args[0]);
+      if (!command)
+	{
+	  builtin_error ("%s: not found", args[0]);
+	  exit_value = EX_NOTFOUND;	/* As per Posix.2, 3.14.6 */
+	  goto failed_exec;
+	}
+
+      command = full_pathname (command);
+      /* If the user wants this to look like a login shell, then
+	 prepend a `-' onto the first argument (argv[0]). */
+      if (dash_name)
+	{
+	  char *new_name = xmalloc (2 + strlen (args[0]));
+	  new_name[0] = '-';
+	  strcpy (new_name + 1, args[0]);
+	  free (args[0]);
+	  args[0] = new_name;
+	}
+
+      /* Decrement SHLVL by 1 so a new shell started here has the same value,
+	 preserving the appearance.  After we do that, we need to change the
+	 exported environment to include the new value. */
+      adjust_shell_level (-1);
+      maybe_make_export_env ();
+
+#if defined (HISTORY)
+      maybe_save_shell_history ();
+#endif /* HISTORY */
+      restore_original_signals ();
+
+#if defined (JOB_CONTROL)
+      if (subshell_environment == 0)
+	end_job_control ();
+#endif /* JOB_CONTROL */
+
+      shell_execve (command, args, export_env);
+
+      adjust_shell_level (1);
+
+      if (!executable_file (command))
+	{
+	  builtin_error ("%s: cannot execute: %s", command, strerror (errno));
+	  exit_value = EX_NOEXEC;	/* As per Posix.2, 3.14.6 */
+	}
+      else
+	file_error (command);
+
+  failed_exec:
+      if (command)
+	free (command);
+
+      if (subshell_environment ||
+	  (!interactive && !find_variable ("no_exit_on_failed_exec")))
+	exit (exit_value);
+
+      initialize_traps ();
+      reinitialize_signals ();
+
+#if defined (JOB_CONTROL)
+      restart_job_control ();
+#endif /* JOB_CONTROL */
+
+      return (exit_value);
+    }
+}

builtins/exit.def

@@ -0,0 +1,129 @@
+This file is exit.def, from which is created exit.c.
+It implements the builtins "exit" and "logout" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES exit.c
+
+$BUILTIN exit
+$FUNCTION exit_builtin
+$SHORT_DOC exit [n]
+Exit the shell with a status of N.  If N is omitted, the exit status
+is that of the last command executed.
+$END
+
+#include <stdio.h>
+#include <sys/types.h>
+#include "../shell.h"
+#include "../jobs.h"
+
+#include "builtext.h"	/* for jobs_builtin */
+
+extern int interactive, login_shell;
+extern int last_command_exit_value;
+
+static int exit_or_logout ();
+static int sourced_logout = 0;
+
+int
+exit_builtin (list)
+     WORD_LIST *list;
+{
+  if (interactive)
+    {
+      fprintf (stderr, login_shell ? "logout\n" : "exit\n");
+      fflush (stderr);
+    }
+
+  return (exit_or_logout (list));
+}
+
+$BUILTIN logout
+$FUNCTION logout_builtin
+$SHORT_DOC logout
+Logout of a login shell.
+$END
+
+/* How to logout. */
+int
+logout_builtin (list)
+     WORD_LIST *list;
+{
+  if (!login_shell && interactive)
+    {
+      builtin_error ("Not login shell: use `exit'");
+      return (EXECUTION_FAILURE);
+    }
+  else
+    return (exit_or_logout (list));
+}
+
+/* Clean up work for exiting or logging out. */
+Function *last_shell_builtin = (Function *)NULL;
+Function *this_shell_builtin = (Function *)NULL;
+
+static int
+exit_or_logout (list)
+     WORD_LIST *list;
+{
+  int exit_value;
+
+#if defined (JOB_CONTROL)
+  int exit_immediate_okay;
+
+  exit_immediate_okay = (!interactive ||
+			 last_shell_builtin == exit_builtin ||
+			 last_shell_builtin == logout_builtin ||
+			 last_shell_builtin == jobs_builtin);
+
+  /* Check for stopped jobs if the user wants to. */
+  if (!exit_immediate_okay)
+    {
+      register int i;
+      for (i = 0; i < job_slots; i++)
+	if (jobs[i] && (jobs[i]->state == JSTOPPED))
+	  {
+	    fprintf (stderr, "There are stopped jobs.\n");
+
+	    /* This is NOT superfluous because EOF can get here without
+	       going through the command parser.  Set both last and this
+	       so that either `exit', `logout', or ^D will work to exit
+	       immediately if nothing intervenes. */
+	    this_shell_builtin = last_shell_builtin = exit_builtin;
+	    return (EXECUTION_FAILURE);
+	  }
+    }
+#endif /* JOB_CONTROL */
+
+  /* Get return value if present.  This means that you can type
+     `logout 5' to a shell, and it returns 5. */
+  if (list)
+    exit_value = get_numeric_arg (list);
+  else
+    exit_value = last_command_exit_value;
+
+  /* Run our `~/.bash_logout' file if it exists, and this is a login shell. */
+  if (login_shell && sourced_logout++ == 0)
+    maybe_execute_file ("~/.bash_logout", 1);
+
+  last_command_exit_value = exit_value;
+
+  /* Exit the program. */
+  longjmp (top_level, EXITPROG);
+}

builtins/fc.def

@@ -0,0 +1,691 @@
+This file is fc.def, from which is created fc.c.
+It implements the builtin "fc" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES fc.c
+
+$BUILTIN fc
+$FUNCTION fc_builtin
+$DEPENDS_ON HISTORY
+$SHORT_DOC fc [-e ename] [-nlr] [first] [last] or fc -s [pat=rep] [cmd]
+
+FIRST and LAST can be numbers specifying the range, or FIRST can be a
+string, which means the most recent command beginning with that
+string.
+
+   -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,
+      then the editor which corresponds to the current readline editing
+      mode, then vi.
+
+   -l means list lines instead of editing.
+   -n means no line numbers listed.
+   -r means reverse the order of the lines (making it newest listed first).
+
+With the `fc -s [pat=rep ...] [command]' format, the command is
+re-executed after the substitution OLD=NEW is performed.
+
+A useful alias to use with this is r='fc -s', so that typing `r cc'
+runs the last command beginning with `cc' and typing `r' re-executes
+the last command.
+$END
+
+#include <stdio.h>
+#include "../bashansi.h"
+#include "../shell.h"
+#if defined (HISTORY)
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include <errno.h>
+#include "../builtins.h"
+#include "../flags.h"
+#include "../maxpath.h"
+#include "../bashhist.h"
+#include <readline/history.h>
+#include "bashgetopt.h"
+
+/* Not all systems declare ERRNO in errno.h... and some systems #define it! */
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+
+extern int echo_input_at_read;
+
+extern int unlink ();
+
+/* **************************************************************** */
+/*								    */
+/*	The K*rn shell style fc command (Fix Command)		    */
+/*								    */
+/* **************************************************************** */
+
+/* fc builtin command (fix command) for Bash for those who
+   like K*rn-style history better than csh-style.
+
+     fc [-e ename] [-nlr] [first] [last]
+
+   FIRST and LAST can be numbers specifying the range, or FIRST can be
+   a string, which means the most recent command beginning with that
+   string.
+
+   -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,
+      then the editor which corresponds to the current readline editing
+      mode, then vi.
+
+   -l means list lines instead of editing.
+   -n means no line numbers listed.
+   -r means reverse the order of the lines (making it newest listed first).
+
+     fc -e - [pat=rep ...] [command]
+     fc -s [pat=rep ...] [command]
+
+   Equivalent to !command:sg/pat/rep execpt there can be multiple PAT=REP's.
+*/
+
+static char *fc_dosubs (), *fc_replace (), *fc_gethist (), *fc_readline ();
+static int fc_gethnum ();
+static void fc_replhist (), fc_addhist ();
+
+/* Data structure describing a list of global replacements to perform. */
+typedef struct repl {
+  struct repl *next;
+  char *pat;
+  char *rep;
+} REPL;
+
+#define USAGE	"usage: fc [-e ename] [-nlr] [first] [last] or fc -s [pat=rep] [command]"
+
+/* Accessors for HIST_ENTRY lists that are called HLIST. */
+#define histline(i) (hlist[(i)]->line)
+#define histdata(i) (hlist[(i)]->data)
+
+#define FREE_RLIST() \
+	do { \
+		for (rl = rlist; rl; ) { \
+			REPL *r;	\
+			r = rl->next; \
+			if (rl->pat) \
+				free (rl->pat); \
+			if (rl->rep) \
+				free (rl->rep); \
+			free (rl); \
+			rl = r; \
+		} \
+	} while (0)
+
+/* String to execute on a file that we want to edit. */
+#define FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-vi}}"
+
+int
+fc_builtin (list)
+     WORD_LIST *list;
+{
+  register int i;
+  register char *sep;
+  int numbering, reverse, listing, execute;
+  int histbeg, histend, last_hist, retval, first, opt;
+  FILE *stream;
+  REPL *rlist = (REPL *) NULL, *rl;
+  char *ename = NULL, *command, *newcom, *line;
+  HIST_ENTRY **hlist;
+  char fn[MAXPATHLEN];
+
+  numbering = 1;
+  reverse = listing = execute = 0;
+
+  /* Parse out the options and set which of the two forms we're in. */
+
+  while (list && *list->word->word == '-')
+    {
+      register char *s = &((list->word->word)[1]);
+
+      if (!isletter (*s))
+	break;
+
+      while (opt = *s++)
+	{
+	  switch (opt)
+	    {
+	    case 'n':
+	      numbering = 0;
+	      break;
+
+	    case 'l':
+	      listing = 1;
+	      break;
+
+	    case 'r':
+	      reverse = 1;
+	      break;
+
+	    case 's':
+	      execute = 1;
+	      break;
+
+	    case 'e':
+	      list = list->next;
+	      if (list == NULL)
+		{
+	          builtin_error (USAGE);
+	          return (EX_USAGE);
+		}
+	      ename = list->word->word;
+	      break;
+
+	    default:
+	      builtin_error (USAGE);
+	      return (EX_USAGE);
+	    }
+	}
+      list = list->next;
+    }
+
+  if (ename && (*ename == '-') && (ename[1] == '\0'))
+    execute = 1;
+
+  /* The "execute" form of the command (re-run, with possible string
+     substitutions). */
+  if (execute)
+    {
+      while (list && ((sep = (char *)strchr (list->word->word, '=')) != NULL))
+	{
+	  *sep++ = '\0';
+	  rl = (REPL *)xmalloc (sizeof (REPL));
+	  rl->next = (REPL *)NULL;
+	  rl->pat = savestring (list->word->word);
+	  rl->rep = savestring (sep);
+
+	  if (rlist == NULL)
+	    rlist = rl;
+	  else
+	    {
+	      rl->next = rlist;
+	      rlist = rl;
+	    }
+	  list = list->next;
+	}
+
+      /* If we have a list of substitutions to do, then reverse it
+	 to get the replacements in the proper order. */
+
+      if (rlist && rlist->next)
+	rlist = (REPL *) reverse_list ((GENERIC_LIST *) rlist);
+
+      hlist = history_list ();
+
+      /* If we still have something in list, it is a command spec.
+	 Otherwise, we use the most recent command in time. */
+      if (list)
+	command = fc_gethist (list->word->word, hlist);
+      else
+	command = fc_gethist ((char *) NULL, hlist);
+
+      if (command == NULL)
+	{
+	  builtin_error ("no command found");
+	  if (rlist)
+	    FREE_RLIST ();
+
+	  return (EXECUTION_FAILURE);
+	}
+
+      if (rlist)
+	{
+	  newcom = fc_dosubs (command, rlist);
+	  free (command);
+	  FREE_RLIST ();
+	  command = newcom;
+	}
+
+      printf ("%s\n", command);
+      fc_replhist (command);	/* replace `fc -e -' with command */
+      return (parse_and_execute (command, "fc", -1));
+    }
+
+  /* This is the second form of the command (the list-or-edit-and-rerun
+     form). */
+  hlist = history_list ();
+  if (hlist == 0)
+    return (EXECUTION_SUCCESS);
+  for (i = 0; hlist[i]; i++);
+
+  /* With the Bash implementation of history, the current command line
+     ("fc blah..." and so on) is already part of the history list by
+     the time we get to this point.  This just skips over that command
+     and makes the last command that this deals with be the last command
+     the user entered before the fc. */
+
+  last_hist = i - 2;
+
+  if (list)
+    {
+      histbeg = fc_gethnum (list->word->word, hlist);
+      list = list->next;
+
+      if (list)
+	histend = fc_gethnum (list->word->word, hlist);
+      else
+	{
+	  if (listing)
+	    histend = last_hist;
+	  else
+	    histend = histbeg;
+	}
+    }
+  else
+    {
+      /* The default for listing is the last 16 history items. */
+      if (listing)
+	{
+	  histend = last_hist;
+	  histbeg = histend - 16;
+	  if (histbeg < 0)
+	    histbeg = 0;
+	}
+      else
+	{
+	  /* For editing, it is the last history command. */
+	  histbeg = histend = last_hist;
+      }
+    }
+
+  /* We print error messages for line specifications out of range. */
+  if ((histbeg < 0) || (histend < 0) ||
+      (histbeg > last_hist) || (histend > last_hist))
+    {
+      builtin_error ("history specification out of range");
+      return (EXECUTION_FAILURE);
+    }
+
+  if (histend < histbeg)
+    {
+      int t = histend;
+
+      histend = histbeg;
+      histbeg = t;
+      reverse = 1;
+    }
+
+  if (listing)
+    stream = stdout;
+  else
+    {
+      numbering = 0;
+      sprintf (fn, "/tmp/bash%d", (int)time ((long *) 0) + (int)getpid ());
+
+      stream = fopen (fn, "w");
+
+      if (!stream)
+	{
+	  builtin_error ("cannot open temp file %s", fn);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+
+  if (!reverse)
+    {
+      for (i = histbeg; i <= histend; i++)
+	{
+	  QUIT;
+	  if (numbering)
+	    fprintf (stream, "%d", i + history_base);
+	  if (listing)
+	    fprintf (stream, "\t%c", histdata (i) ? '*' : ' ');
+	  fprintf (stream, "%s\n", histline (i));
+	}
+    }
+  else
+    {
+      for (i = histend; i >= histbeg; i--)
+	{
+	  QUIT;
+	  if (numbering)
+	    fprintf (stream, "%d", i + history_base);
+	  if (listing)
+	    fprintf (stream, "\t%c", histdata (i) ? '*' : ' ');
+	  fprintf (stream, "%s\n", histline (i));
+	}
+    }
+
+  if (listing)
+    return (EXECUTION_SUCCESS);
+
+  fclose (stream);
+
+  /* Now edit the file of commands. */
+  if (ename)
+    {
+      command = (char *)xmalloc (strlen (ename) + strlen (fn) + 2);
+      sprintf (command, "%s %s", ename, fn);
+    }
+  else
+    {
+      command = (char *)xmalloc (3 + strlen (FC_EDIT_COMMAND) + strlen (fn));
+      sprintf (command, "%s %s", FC_EDIT_COMMAND, fn);
+    }
+  parse_and_execute (command, "fc", -1);
+
+  /* Now reopen the file and execute the edited commands. */
+
+  stream = fopen (fn, "r");
+
+  if (stream == NULL)
+    {
+      builtin_error ("cannot reopen temp file %s", fn);
+      unlink (fn);
+      return (EXECUTION_FAILURE);
+    }
+
+  retval = EXECUTION_SUCCESS;
+  first = 1;
+
+  /* First, write the commands to the history file.  This will not happen
+     when we call parse_and_execute, since parse_and_execute disables
+     the command line history while it executes. */
+     
+  while ((line = fc_readline (stream)) != NULL)
+    {
+      if (line[0] == '\n')
+	{
+	  free (line);
+	  continue;		/* Skip blank lines. */
+	}
+
+      if (first)
+	{
+	  first = 0;
+	  fc_replhist (line);
+	}
+      else
+	fc_addhist (line);
+
+      free (line);
+    }
+  fclose (stream);
+
+  /* Turn on the `v' flag while maybe_execute_file runs so the commands
+     will be echoed as they are read by the parser. */
+  begin_unwind_frame ("fc builtin");
+  add_unwind_protect (unlink, fn);
+  unwind_protect_int (echo_input_at_read);
+  echo_input_at_read = 1;
+    
+  retval = maybe_execute_file (fn, 0);
+
+  run_unwind_frame ("fc builtin");
+
+  return (retval);
+}
+
+/* Return an absolute index into HLIST which corresponds to COMMAND.  If
+   COMMAND is a number, then it was specified in relative terms.  If it
+   is a string, then it is the start of a command line present in HLIST. */
+static int
+fc_gethnum (command, hlist)
+     char *command;
+     HIST_ENTRY **hlist;
+{
+  int sign = 1, n, clen;
+  register int i, j;
+  register char *s;
+
+  /* Count history elements. */
+  for (i = 0; hlist[i]; i++);
+
+  /* With the Bash implementation of history, the current command line
+     ("fc blah..." and so on) is already part of the history list by
+     the time we get to this point.  This just skips over that command
+     and makes the last command that this deals with be the last command
+     the user entered before the fc. */
+  i -= 2;
+
+  /* No specification defaults to most recent command. */
+  if (command == NULL)
+    return (i);
+
+  /* Otherwise, there is a specification.  It can be a number relative to
+     the current position, or an absolute history number. */
+  s = command;
+
+  /* Handle possible leading minus sign. */
+  if (s && (*s == '-'))
+    {
+      sign = -1;
+      s++;
+    }
+
+  if (s && digit(*s))
+    {
+      n = atoi (s);
+      n *= sign;
+
+      /* Anything specified greater than the last history element that we
+	 deal with is an error. */
+      if (n > i + history_base)
+	return (-1);
+
+      /* If the value is negative or zero, then it is an offset from
+	 the current history item. */
+      if (n < 0)
+	return (i + n + 1);
+      else if (n == 0)
+	return (i);
+      else
+	return (n - history_base);
+    }
+
+  clen = strlen (command);
+  for (j = i; j >= 0; j--)
+    {
+      if (STREQN (command, histline (j), clen))
+	return (j);
+    }
+  return (-1);
+}
+
+/* Locate the most recent history line which begins with
+   COMMAND in HLIST, and return a malloc()'ed copy of it. */
+static char *
+fc_gethist (command, hlist)
+     char *command;
+     HIST_ENTRY **hlist;
+{
+  int i;
+
+  if (!hlist)
+    return ((char *)NULL);
+
+  i = fc_gethnum (command, hlist);
+
+  if (i >= 0)
+    return (savestring (histline (i)));
+  else
+    return ((char *)NULL);
+}
+
+/* Read the edited history lines from STREAM and return them
+   one at a time.  This can read unlimited length lines.  The
+   caller should free the storage. */
+static char *
+fc_readline (stream)
+     FILE *stream;
+{
+  register int c;
+  int line_len = 0, lindex = 0;
+  char *line = (char *)NULL;
+
+  while ((c = getc (stream)) != EOF)
+    {
+      if ((lindex + 2) >= line_len)
+	line = (char *) xrealloc (line, (line_len += 128));
+
+      if (c == '\n')
+	{
+	  line[lindex++] = '\n';
+	  line[lindex++] = '\0';
+	  return (line);
+	}
+      else
+	line[lindex++] = c;
+    }
+
+  if (!lindex)
+    {
+      if (line)
+	free (line);
+
+      return ((char *)NULL);
+    }
+
+  if (lindex + 2 >= line_len)
+    line = (char *)xrealloc (line, lindex + 3);
+
+  line[lindex++] = '\n';	    /* Finish with newline if none in file */
+  line[lindex++] = '\0';
+  return (line);
+}
+
+/* Perform the SUBS on COMMAND.
+   SUBS is a list of substitutions, and COMMAND is a simple string.
+   Return a pointer to a malloc'ed string which contains the substituted
+   command. */
+static char *
+fc_dosubs (command, subs)
+     char *command;
+     REPL *subs;
+{
+  register char *new = savestring (command);
+  register REPL *r;
+
+  for (r = subs; r; r = r->next)
+    {
+      register char *t;
+
+      t = fc_replace (r->pat, r->rep, new);
+      free (new);
+      new = t;
+    }
+  return (new);
+}
+
+/* Replace the occurrences of PAT with REP in COMMAND.
+   This returns a new string; the caller should free it. */
+static char *
+fc_replace (pat, rep, command)
+     char *pat, *rep, *command;
+{
+  register int i;
+  int patlen, replen, templen;
+  char *new, *temp;
+
+  patlen = strlen (pat);
+  replen = strlen (rep);
+
+  temp = savestring (command);
+  templen = strlen (temp);
+  i = 0;
+
+  for (; (i + patlen) <= templen; i++)
+    {
+      if (STREQN (temp + i, pat, patlen))
+	{
+	  new = (char *) xmalloc (1 + (replen - patlen) + templen);
+
+	  strncpy (new, temp, i);
+	  strncpy (new + i, rep, replen);
+	  strncpy (new + i + replen,
+		   temp + i + patlen, templen - (i + patlen));
+	  new[templen + (replen - patlen)] = '\0'; /* just in case */
+
+	  free (temp);
+	  temp = new;
+	  i += replen;
+	  templen = strlen (temp);
+	}
+    }
+  return (temp);
+}
+
+/* Use `command' to replace the last entry in the history list, which,
+   by this time, is `fc blah...'.  The intent is that the new command
+   become the history entry, and that `fc' should never appear in the
+   history list.  This way you can do `r' to your heart's content. */
+static void
+fc_replhist (command)
+     char *command;
+{
+  register int i;
+  HIST_ENTRY **hlist, *histent, *discard;
+  char *data;
+  int n;
+
+  if (!command || !*command)
+    return;
+
+  hlist = history_list ();
+
+  if (hlist == NULL)
+    return;
+
+  for (i = 0; hlist[i]; i++);
+  i--;
+
+  /* History_get () takes a parameter that should be
+     offset by history_base. */
+
+  histent = history_get (history_base + i);	/* Don't free this */
+  if (histent == NULL)
+    return;
+
+  n = strlen (command);
+
+  if (command[n - 1] == '\n')
+    command[n - 1] = '\0';
+
+  if (command && *command)
+    {
+      discard = remove_history (i);
+      if (discard)
+	{
+	  if (discard->line)
+	    free (discard->line);
+	  free ((char *) discard);
+	}
+      maybe_add_history (command);	/* Obeys HISTCONTROL setting. */
+    }
+}
+
+/* Add LINE to the history, after removing a single trailing newline. */
+static void
+fc_addhist (line)
+     char *line;
+{
+  register int n;
+
+  n = strlen (line);
+
+  if (line[n - 1] == '\n')
+    line[n - 1] = '\0';
+
+  if (line && *line)
+    maybe_add_history (line);
+}
+#endif /* HISTORY */

builtins/fg_bg.def

@@ -0,0 +1,145 @@
+This file is fg_bg.def, from which is created fg_bg.c.
+It implements the builtins "bg" and "fg" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES fg_bg.c
+
+$BUILTIN fg
+$FUNCTION fg_builtin
+$DEPENDS_ON JOB_CONTROL
+$SHORT_DOC fg [job_spec]
+Place JOB_SPEC in the foreground, and make it the current job.  If
+JOB_SPEC is not present, the shell's notion of the current job is
+used.
+$END
+
+#include <sys/types.h>
+#include <signal.h>
+#include "../shell.h"
+#include "../jobs.h"
+
+#if defined (JOB_CONTROL)
+extern char *this_command_name;
+
+static int fg_bg ();
+
+/* How to bring a job into the foreground. */
+int
+fg_builtin (list)
+     WORD_LIST *list;
+{
+  int fg_bit = 1;
+  register WORD_LIST *t = list;
+
+  if (!job_control)
+    {
+      builtin_error ("no job control");
+      return (EXECUTION_FAILURE);
+    }
+
+  /* If the last arg on the line is '&', then start this job in the
+     background.  Else, fg the job. */
+
+  while (t && t->next)
+    t = t->next;
+
+  if (t && t->word->word[0] == '&' && !t->word->word[1])
+    fg_bit = 0;
+
+  return (fg_bg (list, fg_bit));
+}
+#endif /* JOB_CONTROL */
+
+$BUILTIN bg
+$FUNCTION bg_builtin
+$DEPENDS_ON JOB_CONTROL
+$SHORT_DOC bg [job_spec]
+Place JOB_SPEC in the background, as if it had been started with
+`&'.  If JOB_SPEC is not present, the shell's notion of the current
+job is used.
+$END
+
+#if defined (JOB_CONTROL)
+/* How to put a job into the background. */
+int
+bg_builtin (list)
+     WORD_LIST *list;
+{
+  if (!job_control)
+    {
+      builtin_error ("no job control");
+      return (EXECUTION_FAILURE);
+    }
+
+  return (fg_bg (list, 0));
+}
+
+/* How to put a job into the foreground/background. */
+static int
+fg_bg (list, foreground)
+     WORD_LIST *list;
+     int foreground;
+{
+  sigset_t set, oset;
+  int job, status = EXECUTION_SUCCESS, old_async_pid;
+
+  BLOCK_CHILD (set, oset);
+  job = get_job_spec (list);
+
+  if (job < 0 || job >= job_slots || !jobs[job])
+    {
+      if (job != DUP_JOB)
+	builtin_error ("No such job %s", list ? list->word->word : "");
+
+      goto failure;
+    }
+
+  /* Or if jobs[job]->pgrp == shell_pgrp. */
+  if (!(jobs[job]->flags & J_JOBCONTROL))
+    {
+      builtin_error ("job %%%d started without job control", job + 1);
+      goto failure;
+    }
+
+  if (!foreground)
+    {
+      old_async_pid = last_asynchronous_pid;
+      last_asynchronous_pid = jobs[job]->pgrp;	/* As per Posix.2 5.4.2 */
+    }
+
+  status = start_job (job, foreground);
+
+  if (status >= 0)
+    {
+    /* win: */
+      UNBLOCK_CHILD (oset);
+      return (status);
+    }
+  else
+    {
+      if (!foreground)
+	last_asynchronous_pid = old_async_pid;
+
+    failure:
+      UNBLOCK_CHILD (oset);
+      return (EXECUTION_FAILURE);
+    }
+}
+#endif /* JOB_CONTROL */

builtins/getopt.c

@@ -0,0 +1,283 @@
+/* getopt for BASH.
+
+   Copyright (C) 1993, 1994
+   	Free Software Foundation, Inc.
+
+   This program 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.
+
+   This program 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 this program; if not, write to the Free Software
+   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <stdio.h>
+#include "../memalloc.h"
+#include "../shell.h"
+#include "getopt.h"
+
+/* 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 `sh_getopt'.
+
+   On entry to `sh_getopt', zero means this is the first call; initialize.
+
+   When `sh_getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   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 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.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   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 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 sh_optopt = '?';
+
+/* 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 `sh_getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   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, `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 `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 `sh_optarg'. */
+
+/* 1003.2 specifies the format of this message.  */
+#define BADOPT(x)  fprintf (stderr, "%s: illegal option -- %c\n", argv[0], x)
+#define NEEDARG(x) fprintf (stderr, "%s: option requires an argument -- %c\n", argv[0], x)
+
+int
+sh_getopt (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  int option_index;
+  char c, *temp;
+
+  sh_optarg = 0;
+
+  if (sh_optind > argc || sh_optind < 0)
+    {
+      sh_optind = argc;
+      return (EOF);
+    }
+
+  /* Initialize the internal data when the first call is made.
+     Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  if (sh_optind == 0)
+    {
+      sh_optind = 1;
+      nextchar = (char *)NULL;
+    }
+
+  if (nextchar == 0 || *nextchar == '\0')
+    {
+      /* If we have done all the ARGV-elements, stop the scan
+	 and back over any non-options that we skipped and permuted.  */
+      if (sh_optind == argc)
+	return EOF;
+
+      temp = argv[sh_optind];
+
+      /* Special ARGV-element `--' means premature end of options.
+	 Skip it like a null option, and return EOF. */
+      if (temp[0] == '-' && temp[1] == '-' && temp[2] == '\0')
+	{
+	  sh_optind++;
+	  return EOF;
+	}
+
+      /* 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[sh_curopt = sh_optind] + 1;
+      sh_charindex = 1;
+    }
+
+  /* Look at and handle the next option-character.  */
+
+  c = *nextchar++; sh_charindex++;
+  temp = strchr (optstring, c);
+
+  /* Increment `sh_optind' when we start to process its last character.  */
+  if (nextchar == 0 || *nextchar == '\0')
+    {
+      sh_optind++;
+      nextchar = (char *)NULL;
+    }
+
+  sh_optopt = c;
+
+  if (temp == NULL || c == ':')
+    {
+      if (sh_opterr)
+	BADOPT (c);
+
+      return '?';
+    }
+
+  if (temp[1] == ':')
+    {
+      if (nextchar && *nextchar)
+	{
+	  /* 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++;
+	}
+      else if (sh_optind == argc)
+	{
+	  if (sh_opterr)
+	    NEEDARG (c);
+
+	  sh_optopt = c;
+	  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;
+    }
+  return c;
+}
+
+void
+sh_getopt_restore_state (argv)
+     char **argv;
+{
+  if (nextchar)
+    nextchar = argv[sh_curopt] + sh_charindex;
+}
+
+#ifdef TEST
+
+/* Compile with -DTEST to make an executable for use in testing
+   the above definition of `sh_getopt'.  */
+
+int
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  int c;
+  int digit_sh_optind = 0;
+
+  while (1)
+    {
+      int this_option_sh_optind = sh_optind ? sh_optind : 1;
+
+      c = sh_getopt (argc, argv, "abc:d:0123456789");
+      if (c == EOF)
+	break;
+
+      switch (c)
+	{
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	  if (digit_sh_optind != 0 && digit_sh_optind != this_option_sh_optind)
+	    printf ("digits occur in two different argv-elements.\n");
+	  digit_sh_optind = this_option_sh_optind;
+	  printf ("option %c\n", c);
+	  break;
+
+	case 'a':
+	  printf ("option a\n");
+	  break;
+
+	case 'b':
+	  printf ("option b\n");
+	  break;
+
+	case 'c':
+	  printf ("option c with value `%s'\n", sh_optarg);
+	  break;
+
+	case '?':
+	  break;
+
+	default:
+	  printf ("?? sh_getopt returned character code 0%o ??\n", c);
+	}
+    }
+
+  if (sh_optind < argc)
+    {
+      printf ("non-option ARGV-elements: ");
+      while (sh_optind < argc)
+	printf ("%s ", argv[sh_optind++]);
+      printf ("\n");
+    }
+
+  exit (0);
+}
+
+#endif /* TEST */

builtins/getopt.h

@@ -0,0 +1,57 @@
+/* Declarations for getopt.
+   Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
+
+   This program 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.
+
+   This program 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 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
+
+/* 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 *sh_optarg;
+
+/* 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'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns EOF, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `sh_optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+extern int sh_optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+   for unrecognized options.  */
+
+extern int sh_opterr;
+
+/* Set to an option character which was unrecognized.  */
+
+extern int sh_optopt;
+
+extern int sh_getopt ();
+extern void sh_getopt_restore_state ();
+
+#endif /* _GETOPT_H */

builtins/getopts.def

@@ -0,0 +1,300 @@
+This file is getopts.def, from which is created getopts.c.
+It implements the builtin "getopts" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES getopts.c
+
+$BUILTIN getopts
+$DEPENDS_ON GETOPTS_BUILTIN
+$FUNCTION getopts_builtin
+$SHORT_DOC getopts optstring name [arg]
+Getopts is used by shell procedures to parse positional parameters.
+
+OPTSTRING contains the option letters to be recognized; if a letter
+is followed by a colon, the option is expected to have an argument,
+which should be separated from it by white space.
+
+Each time it is invoked, getopts will place the next option in the
+shell variable $name, initializing name if it does not exist, and
+the index of the next argument to be processed into the shell
+variable OPTIND.  OPTIND is initialized to 1 each time the shell or
+a shell script is invoked.  When an option requires an argument,
+getopts places that argument into the shell variable OPTARG.
+
+getopts reports errors in one of two ways.  If the first character
+of OPTSTRING is a colon, getopts uses silent error reporting.  In
+this mode, no error messages are printed.  If an illegal option is
+seen, getopts places the option character found into OPTARG.  If a
+required argument is not found, getopts places a ':' into NAME and
+sets OPTARG to the option character found.  If getopts is not in
+silent mode, and an illegal option is seen, getopts places '?' into
+NAME and unsets OPTARG.  If a required option is not found, a '?'
+is placed in NAME, OPTARG is unset, and a diagnostic message is
+printed.
+
+If the shell variable OPTERR has the value 0, getopts disables the
+printing of error messages, even if the first character of
+OPTSTRING is not a colon.  OPTERR has the value 1 by default.
+
+Getopts normally parses the positional parameters ($0 - $9), but if
+more arguments are given, they are parsed instead.
+$END
+
+#include <stdio.h>
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+
+#if defined (GETOPTS_BUILTIN)
+#include "getopt.h"
+
+#define G_EOF		(-1)
+#define G_ILLEGAL_OPT	(-2)
+#define G_ARG_MISSING	(-3)
+
+extern char *this_command_name;
+extern WORD_LIST *rest_of_args;
+
+/* getopts_reset is magic code for when OPTIND is reset.  N is the
+   value that has just been assigned to OPTIND. */
+void
+getopts_reset (newind)
+     int newind;
+{
+  sh_optind = newind;
+}
+
+/* Error handling is now performed as specified by Posix.2, draft 11
+   (identical to that of ksh-88).  The special handling is enabled if
+   the first character of the option string is a colon; this handling
+   disables diagnostic messages concerning missing option arguments
+   and illegal option characters.  The handling is as follows.
+
+   ILLEGAL OPTIONS:
+        name -> "?"
+        if (special_error) then
+                OPTARG = option character found
+                no error output
+        else
+                OPTARG unset
+                diagnostic message
+        fi
+ 
+  MISSING OPTION ARGUMENT;
+        if (special_error) then
+                name -> ":"
+                OPTARG = option character found
+        else
+                name -> "?"
+                OPTARG unset
+                diagnostic message
+        fi
+ */
+
+static int
+dogetopts (argc, argv)
+     int argc;
+     char **argv;
+{
+  int ret, special_error, old_opterr = 0, i, n;
+  char strval[2], numval[16];
+  char *optstr;			/* list of options */
+  char *name;			/* variable to get flag val */
+  char *t;
+
+  if (argc < 3)
+    {
+      builtin_error("usage: getopts optstring name [arg]");
+      return (EX_USAGE);
+    }
+
+  /* argv[0] is "getopts". */
+
+  optstr = argv[1];
+  name = argv[2];
+  argc -= 2;
+  argv += 2;
+
+  special_error = optstr[0] == ':';
+
+  if (special_error)
+    {
+      old_opterr = sh_opterr;
+      optstr++;
+      sh_opterr = 0;		/* suppress diagnostic messages */
+    }
+
+  if (argc > 1)
+    {
+      sh_getopt_restore_state (argv);
+      t = argv[0];
+      argv[0] = dollar_vars[0];
+      ret = sh_getopt (argc, argv, optstr);
+      argv[0] = t;
+    }
+  else if (rest_of_args == (WORD_LIST *)NULL)
+    {
+      register int i;
+
+      for (i = 0; i < 10 && dollar_vars[i]; i++);
+      ret = sh_getopt (i, dollar_vars, optstr);
+    }
+  else
+    {
+      register int i;
+      register WORD_LIST *words;
+      char **v;
+
+      for (i = 0; i < 10 && dollar_vars[i]; i++);
+      for (words = rest_of_args; words; words = words->next, i++);
+      v = (char **)xmalloc ((i + 1) * sizeof (char *));
+      for (i = 0; i < 10 && dollar_vars[i]; i++)
+        v[i] = dollar_vars[i];
+      for (words = rest_of_args; words; words = words->next, i++)
+        v[i] = words->word->word;
+      v[i] = (char *)NULL;
+      ret = sh_getopt (i, v, optstr);
+      free (v);
+    }
+
+  if (special_error)
+    sh_opterr = old_opterr;
+
+  /* Set the OPTIND variable in any case, to handle "--" skipping. */
+  if (sh_optind < 10)
+    {
+      numval[14] = sh_optind + '0';
+      numval[15] = '\0';
+      i = 14;
+    }
+  else
+    {
+      numval[i = 15] = '\0';
+      n = sh_optind;
+      do
+	{
+	  numval[--i] = (n % 10) + '0';
+	}
+      while (n /= 10);
+    }
+  bind_variable ("OPTIND", numval + i);
+
+  /* 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 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 (sh_optarg == NULL)
+	ret = G_ILLEGAL_OPT;
+      else if (sh_optarg[0] == '\0')
+	ret = G_ARG_MISSING;
+    }
+	    
+  if (ret == G_EOF)
+    {
+      bind_variable (name, "?");
+      return (EXECUTION_FAILURE);
+    }
+
+  if (ret == G_ILLEGAL_OPT)
+    {
+      /* Illegal option encountered. */
+      strval[0] = '?';
+      strval[1] = '\0';
+      bind_variable (name, strval);
+
+      if (special_error)
+	{
+	  strval[0] = (char) sh_optopt;
+	  strval[1] = '\0';
+	  bind_variable ("OPTARG", strval);
+	}
+      else
+	makunbound ("OPTARG", shell_variables);
+      return (EXECUTION_SUCCESS);
+    }
+
+  if (ret == G_ARG_MISSING)
+    {
+      /* Required argument missing. */
+      if (special_error)
+	{
+	  strval[0] = ':';
+	  strval[1] = '\0';
+	  bind_variable (name, strval);
+
+	  strval[0] = (char) sh_optopt;
+	  strval[1] = '\0';
+	  bind_variable ("OPTARG", strval);
+	}
+      else
+	{
+	  strval[0] = '?';
+	  strval[1] = '\0';
+	  bind_variable (name, strval);
+	  makunbound ("OPTARG", shell_variables);
+	}
+      return (EXECUTION_SUCCESS);
+    }			
+
+  bind_variable ("OPTARG", sh_optarg);
+
+  strval[0] = (char) ret;
+  strval[1] = '\0';
+  bind_variable (name, strval);
+
+  return (EXECUTION_SUCCESS);
+}
+
+/* The getopts builtin.  Build an argv, and call dogetopts with it. */
+int
+getopts_builtin (list)
+     WORD_LIST *list;
+{
+  register int	i;
+  char **av;
+  int ac, ret;
+  WORD_LIST *t;
+
+  if (list == 0)
+    return EXECUTION_FAILURE;
+
+  for (t = list, ac = 0; t; t = t->next, ac++);
+
+  ac++;
+  av = (char **)xmalloc ((1 + ac) * sizeof (char *));
+  av[ac] = (char *) NULL;
+  av[0] = this_command_name;
+
+  for (t = list, i = 1; t; t = t->next, i++)
+    av[i] = t->word->word;
+
+  ret = dogetopts (ac, av);
+  free ((char *)av);
+  return (ret);
+}
+#endif /* GETOPTS_BUILTIN */

builtins/hash.def

@@ -0,0 +1,222 @@
+This file is hash.def, from which is created hash.c.
+It implements the builtin "hash" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES hash.c
+
+$BUILTIN hash
+$FUNCTION hash_builtin
+$SHORT_DOC hash [-r] [name ...]
+For each NAME, the full pathname of the command is determined and
+remembered.  The -r option causes the shell to forget all remembered
+locations.  If no arguments are given, information about remembered
+commands is presented.
+$END
+
+#include <sys/types.h>
+#include "../posixstat.h"
+
+#include <stdio.h>
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+#include "../builtins.h"
+#include "../flags.h"
+#include "hashcom.h"
+#include "common.h"
+#include "../execute_cmd.h"
+
+extern int dot_found_in_search;
+
+void
+initialize_filename_hashing ()
+{
+  hashed_filenames = make_hash_table (FILENAME_HASH_BUCKETS);
+}
+
+/* Print statistics on the current state of hashed commands.  If LIST is
+   not empty, then rehash (or hash in the first place) the specified
+   commands. */
+hash_builtin (list)
+     WORD_LIST *list;
+{
+  int expunge_hash_table = 0;
+  int any_failed = 0;
+
+  if (hashing_disabled)
+    {
+      builtin_error ("hashing disabled");
+      return (EXECUTION_FAILURE);
+    }
+
+  while (list)
+    {
+      char *arg = list->word->word;
+
+      if (ISOPTION (arg, 'r'))
+	{
+	  expunge_hash_table = 1;
+	  list = list->next;
+	}
+      else if (ISOPTION (arg, '-'))
+	{
+	  list = list->next;
+	  break;
+	}
+      else if (*arg == '-')
+	{
+	  bad_option (list->word->word);
+	  builtin_error ("usage: hash [-r] [command ...]");
+	  return (EX_USAGE);
+	}
+      else
+	break;
+    }
+
+  /* We want hash -r to be silent, but hash -- to print hashing info.  That
+     is the reason for the !expunge_hash_table. */
+  if (!list && !expunge_hash_table)
+    {
+      /* Print information about current hashed info. */
+      int any_printed = 0;
+      int bucket = 0;
+      register BUCKET_CONTENTS *item_list;
+
+      while (bucket < hashed_filenames->nbuckets)
+	{
+	  item_list = get_hash_bucket (bucket, hashed_filenames);
+	  if (item_list)
+	    {
+	      if (!any_printed)
+		{
+		  printf ("hits\tcommand\n");
+		  any_printed++;
+		}
+	      while (item_list)
+		{
+		  printf ("%4d\t%s\n",
+			  item_list->times_found, pathdata(item_list)->path);
+		  item_list = item_list->next;
+		}
+	    }
+	  bucket++;
+	}
+
+      if (!any_printed)
+	printf ("No commands in hash table.\n");
+
+      return (EXECUTION_SUCCESS);
+    }
+
+  if (expunge_hash_table)
+    {
+      int bucket = 0;
+      register BUCKET_CONTENTS *item_list, *prev;
+
+      while (bucket < hashed_filenames->nbuckets)
+	{
+	  item_list = get_hash_bucket (bucket, hashed_filenames);
+	  if (item_list)
+	    {
+	      while (item_list)
+		{
+		  prev = item_list;
+		  free (item_list->key);
+		  free (pathdata(item_list)->path);
+		  free (item_list->data);
+		  item_list = item_list->next;
+		  free (prev);
+		}
+	      hashed_filenames->bucket_array[bucket] = (BUCKET_CONTENTS *)NULL;
+	    }
+	  bucket++;
+	}
+    }
+
+  while (list)
+    {
+      /* Add or rehash the specified commands. */
+      char *word;
+      char *full_path;
+      SHELL_VAR *var;
+
+      word = list->word->word;
+      if (absolute_program (word))
+	{
+	  list = list->next;
+	  continue;
+	}
+      full_path = find_user_command (word);
+      var = find_function (word);
+
+      if (!find_shell_builtin (word) && (!var))
+	{
+	  if (full_path && executable_file (full_path))
+	    remember_filename (word, full_path, dot_found_in_search, 0);
+	  else
+	    {
+	      builtin_error ("%s: not found", word);
+	      any_failed++;
+	    }
+	}
+      if (full_path)
+	free (full_path);
+
+      list = list->next;
+    }
+
+  fflush (stdout);
+
+  if (any_failed)
+    return (EXECUTION_FAILURE);
+  else
+    return (EXECUTION_SUCCESS);
+}
+
+/* Place FILENAME (key) and FULL_PATHNAME (data->path) into the
+   hash table.  CHECK_DOT if non-null is for future calls to
+   find_hashed_filename ().  FOUND is the initial value for
+   times_found. */
+void
+remember_filename (filename, full_pathname, check_dot, found)
+     char *filename, *full_pathname;
+     int check_dot, found;
+{
+  register BUCKET_CONTENTS *item;
+
+  if (hashing_disabled)
+    return;
+  item = add_hash_item (filename, hashed_filenames);
+  if (item->data)
+    free (pathdata(item)->path);
+  else
+    {
+      item->key = savestring (filename);
+      item->data = (char *)xmalloc (sizeof (PATH_DATA));
+    }
+  pathdata(item)->path = savestring (full_pathname);
+  pathdata(item)->check_dot = check_dot;
+  item->times_found = found;
+}

builtins/hashcom.h

@@ -0,0 +1,32 @@
+/* hashcom.h - Common defines for hashing filenames. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "../hash.h"
+
+#define FILENAME_HASH_BUCKETS 631
+
+extern HASH_TABLE *hashed_filenames;
+
+typedef struct {
+  char *path;		/* The full pathname of the file. */
+  int check_dot;	/* Whether `.' appeared before this one in $PATH. */
+} PATH_DATA;
+
+#define pathdata(x) ((PATH_DATA *)(x)->data)

builtins/help.def

@@ -0,0 +1,134 @@
+This file is help.def, from which is created help.c.
+It implements the builtin "help" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES help.c
+
+$BUILTIN help
+$FUNCTION help_builtin
+$SHORT_DOC help [pattern ...]
+Display helpful information about builtin commands.  If PATTERN is
+specified, gives detailed help on all commands matching PATTERN,
+otherwise a list of the builtins is printed.
+$END
+
+#include <stdio.h>
+#include "../shell.h"
+#include "../builtins.h"
+
+#if defined (USE_GLOB_LIBRARY)
+#  include <glob/glob.h>
+#else
+#  define FNM_NOMATCH 1
+#endif /* USE_GLOB_LIBRARY */
+
+/* Print out a list of the known functions in the shell, and what they do.
+   If LIST is supplied, print out the list which matches for each pattern
+   specified. */
+help_builtin (list)
+     WORD_LIST *list;
+{
+  if (!list)
+    {
+      register int i, j;
+      char blurb[256];
+
+      show_shell_version ();
+      printf (
+"Shell commands that are defined internally.  Type `help' to see this list.\n\
+Type `help name' to find out more about the function `name'.\n\
+Use `info bash' to find out more about the shell in general.\n\
+\n\
+A star (*) next to a name means that the command is disabled.\n\
+\n");
+
+      for (i = 0; i < num_shell_builtins; i++)
+	{
+	  QUIT;
+	  sprintf (blurb, "%c%s",
+		   (shell_builtins[i].flags & BUILTIN_ENABLED) ? ' ' : '*',
+		   shell_builtins[i].short_doc);
+
+	  blurb[35] = '\0';
+	  printf ("%s", blurb);
+
+	  if (i % 2)
+	    printf ("\n");
+	  else
+	    for (j = strlen (blurb); j < 35; j++)
+	      putc (' ', stdout);
+
+	}
+      if (i % 2)
+	printf ("\n");
+    }
+  else
+    {
+      int match_found = 0;
+      char *pattern = "";
+
+      if (glob_pattern_p (list->word->word))
+	{
+	  printf ("Shell commands matching keyword%s `",
+		  list->next ? "s" : "");
+	  print_word_list (list, ", ");
+	  printf ("'\n\n");
+	}
+
+      while (list)
+	{
+	  register int i = 0, plen;
+	  char *name;
+
+	  pattern = list->word->word;
+	  plen = strlen (pattern);
+
+	  while (name = shell_builtins[i].name)
+	    {
+	      int doc_index;
+
+	      QUIT;
+	      if ((strncmp (pattern, name, plen) == 0) ||
+		  (fnmatch (pattern, name, 0) != FNM_NOMATCH))
+		{
+		  printf ("%s: %s\n", name, shell_builtins[i].short_doc);
+
+		  for (doc_index = 0;
+		       shell_builtins[i].long_doc[doc_index]; doc_index++)
+		    printf ("    %s\n", shell_builtins[i].long_doc[doc_index]);
+
+		  match_found++;
+		}
+	      i++;
+	    }
+	  list = list->next;
+	}
+
+      if (!match_found)
+	{
+	  fprintf (stderr, "No help topics match `%s'.  Try `help help'.\n",
+		   pattern);
+	  fflush (stderr);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+  fflush (stdout);
+  return (EXECUTION_SUCCESS);
+}

builtins/history.def

@@ -0,0 +1,179 @@
+This file is history.def, from which is created history.c.
+It implements the builtin "history" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES history.c
+
+$BUILTIN history
+$FUNCTION history_builtin
+$DEPENDS_ON HISTORY
+$SHORT_DOC history [n] [ [-awrn] [filename]]
+Display the history list with line numbers.  Lines listed with
+with a `*' have been modified.  Argument of N says to list only
+the last N lines.  Argument `-w' means to write out the current
+history file;  `-r' means to read it instead.  Argument `-a' means
+to append history lines from this session to the history file.
+Argument `-n' means to read all history lines not already read
+from the history file.  If FILENAME is given, then use that file,
+else if $HISTFILE has a value, use that, else use ~/.bash_history.
+$END
+
+#include "../shell.h"
+#if defined (HISTORY)
+#include <sys/types.h>
+#include <sys/file.h>
+#include "../filecntl.h"
+#include "../posixstat.h"
+#include "../bashhist.h"
+#include <readline/history.h>
+
+/* History.  Arg of -w FILENAME means write file, arg of -r FILENAME
+   means read file.  Arg of N means only display that many items. */
+
+history_builtin (list)
+     WORD_LIST *list;
+{
+  register int i;
+  int limited = 0, limit = 0;
+  HIST_ENTRY **hlist;
+
+  while (list)
+    {
+      char *arg = list->word->word;
+
+      if ((arg[0] == '-') &&
+	  (strlen (arg) == 2) &&
+	  (member (arg[1], "rwan")))
+	{
+	  char *file;
+	  int result = EXECUTION_SUCCESS;
+
+	  if (list->next)
+	    file = list->next->word->word;
+	  else
+	    file = get_string_value ("HISTFILE");
+
+	  switch (arg[1])
+	    {
+	    case 'a':		/* Append `new' lines to file. */
+	      {
+		if (history_lines_this_session)
+		  {
+		    void using_history ();
+
+		    if (history_lines_this_session < where_history ())
+		      {
+			/* If the filename was supplied, then create it
+			   if it doesn't already exist. */
+			if (file)
+			  {
+			    struct stat buf;
+
+			    if (stat (file, &buf) == -1)
+			      {
+				int tem;
+
+				tem = open (file, O_CREAT, 0666);
+				close (tem);
+			      }
+			  }
+
+			result =
+			  append_history (history_lines_this_session, file);
+			history_lines_in_file += history_lines_this_session;
+			history_lines_this_session = 0;
+		      }
+		  }
+		break;
+	      }
+
+	    case 'w':		/* Write entire history. */
+	      {
+		result = write_history (file);
+		break;
+	      }
+
+	    case 'r':		/* Read entire file. */
+	      {
+		result = read_history (file);
+		break;
+	      }
+
+	    case 'n':		/* Read `new' history from file. */
+	      {
+		/* Read all of the lines in the file that we haven't
+		   already read. */
+		using_history ();
+		result = read_history_range (file, history_lines_in_file, -1);
+		using_history ();
+		history_lines_in_file = where_history ();
+
+		break;
+	      }
+	    }
+	  return (result ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
+	}
+      else if (strcmp (list->word->word, "--") == 0)
+	{
+	  list = list->next;
+	  break;
+	}
+      else if (*list->word->word == '-')
+	{
+	  bad_option (list->word->word);
+	  builtin_error ("usage: history [n] [-rwan [filename]]");
+	  return (EX_USAGE);
+	}
+      else
+	break;
+    }
+
+  if (list)
+    {
+      limited = 1;
+      limit = get_numeric_arg (list);
+    }
+
+  hlist = history_list ();
+
+  if (hlist)
+    {
+      for (i = 0;  hlist[i]; i++);
+
+      if (limit < 0)
+	limit = -limit;
+
+      if (!limited)
+	i = 0;
+      else
+	if ((i -= limit) < 0)
+	  i = 0;
+
+      while (hlist[i])
+	{
+	  QUIT;
+	  printf ("%5d%c %s\n", i + history_base,
+		  hlist[i]->data ? '*' : ' ', hlist[i]->line);
+	  i++;
+	}
+    }
+  return (EXECUTION_SUCCESS);
+}
+#endif /* HISTORY */

builtins/inlib.def

@@ -0,0 +1,74 @@
+This file is inlib.def, from which is created inlib.c.
+It implements the Apollo-specific builtin "inlib" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES inlib.c
+#include <stdio.h>
+#include "../shell.h"
+
+$BUILTIN inlib
+$FUNCTION inlib_builtin
+$DEPENDS_ON apollo
+$SHORT_DOC inlib pathname [pathname...]
+Install a user-supplied library specified by pathname in the current
+shell process. The library is used to resolve external references
+in programs and libraries loaded after its installation.  Note
+that the library is not loaded into the address space unless it is
+needed to resolve an external reference.  The list of inlibed
+libraries is passed to all children of the current shell.
+$END
+
+#if defined (apollo)
+
+#include <apollo/base.h>
+#include <apollo/loader.h>
+
+inlib_builtin (list)
+     WORD_LIST *list;
+{
+  status_$t status;
+  int return_value;
+  short len;
+
+  if (!list)
+    {
+      builtin_error ("usage: inlib pathname [pathname...]");
+      return (EX_USAGE);
+    }
+
+  return_value = EXECUTION_SUCCESS;
+
+  while (list)
+    {
+      len = (short)strlen (list->word->word);
+      loader_$inlib (list->word->word, len, &status);
+
+      if (status.all != status_$ok)
+	{
+	  builtin_error ("inlib failed for %s", list->word->word);
+	  return_value = EXECUTION_FAILURE;
+	}
+
+      list = list->next;
+    }
+
+  return (return_value);
+}
+#endif /* apollo */

builtins/jobs.def

@@ -0,0 +1,171 @@
+This file is jobs.def, from which is created jobs.c.
+It implements the builtin "jobs" in Bash.
+
+Copyright (C) 1987, 1989, 1991, 1992 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES jobs.c
+
+$BUILTIN jobs
+$FUNCTION jobs_builtin
+$DEPENDS_ON JOB_CONTROL
+$SHORT_DOC jobs [-lnp] [jobspec ...] | jobs -x command [args]
+Lists the active jobs.  The -l option lists process id's in addition
+to the normal information; the -p option lists process id's only.
+If -n is given, only processes that have changed status since the last
+notification are printed.  JOBSPEC restricts output to that job.
+If -x is given, COMMAND is run after all job specifications that appear
+in ARGS have been replaced with the process ID of that job's process group
+leader.
+$END
+
+#include "../shell.h"
+
+#if defined (JOB_CONTROL)
+#include <sys/types.h>
+#include <signal.h>
+#include "../jobs.h"
+
+#include "bashgetopt.h"
+
+extern int job_control, interactive_shell;
+static int execute_list_with_replacements ();
+
+/* The `jobs' command.  Prints outs a list of active jobs.  If the
+   argument `-l' is given, then the process id's are printed also.
+   If the argument `-p' is given, print the process group leader's
+   pid only.  If `-n' is given, only processes that have changed
+   status since the last notification are printed.  If -x is given,
+   replace all job specs with the pid of the appropriate process
+   group leader and execute the command. */
+int
+jobs_builtin (list)
+     WORD_LIST *list;
+{
+  int form = JLIST_STANDARD, execute = 0;
+  int opt;
+  int any_failed = 0;
+
+  if (!job_control && !interactive_shell)
+    return (EXECUTION_SUCCESS);
+
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, "lpnx")) != -1)
+    {
+      switch (opt)
+	{
+	case 'l':
+	  form = JLIST_LONG;
+	  break;
+	case 'p':
+	  form = JLIST_PID_ONLY;
+	  break;
+	case 'n':
+	  form = JLIST_CHANGED_ONLY;
+	  break;
+	case 'x':
+	  if (form != JLIST_STANDARD)
+	    {
+	      builtin_error ("Other options not allowed with `-x'");
+	      return (EXECUTION_FAILURE);
+	    }
+	  execute++;
+	  break;
+
+	default:
+	  builtin_error ("usage: jobs [-lpn [jobspec]] [-x command [args]]");
+	  return (EX_USAGE);
+	}
+    }
+
+  list = loptend;
+
+  if (execute)
+    return (execute_list_with_replacements (list));
+
+  if (!list)
+    {
+      list_jobs (form);
+      return (EXECUTION_SUCCESS);
+    }
+
+  while (list)
+    {
+      int job;
+      sigset_t set, oset;
+
+      BLOCK_CHILD (set, oset);
+      job = get_job_spec (list);
+
+      if ((job == NO_JOB) || !jobs || !jobs[job])
+	{
+	  builtin_error ("No such job %s", list->word->word);
+	  any_failed++;
+	}
+      else if (job != DUP_JOB)
+	list_one_job ((JOB *)NULL, form, 0, job);
+
+      UNBLOCK_CHILD (oset);
+      list = list->next;
+    }
+  return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
+}
+
+static int
+execute_list_with_replacements (list)
+     WORD_LIST *list;
+{
+  register WORD_LIST *l;
+  int job, result;
+
+  /* First do the replacement of job specifications with pids. */
+  for (l = list; l; l = l->next)
+    {
+      if (l->word->word[0] == '%')	/* we have a winner */
+	{
+	  job = get_job_spec (l);
+
+	  /* A bad job spec is not really a job spec! Pass it through. */
+	  if (job < 0 || job >= job_slots || !jobs[job])
+	    continue;
+
+	  free (l->word->word);
+	  l->word->word = itos (jobs[job]->pgrp);
+	}
+    }
+
+  /* Next make a new simple command and execute it. */
+  begin_unwind_frame ("jobs_builtin");
+  {
+    COMMAND *command = (COMMAND *)NULL;
+
+    add_unwind_protect (dispose_command, command);
+
+    command = make_bare_simple_command ();
+    command->value.Simple->words = copy_word_list (list);
+    command->value.Simple->redirects = (REDIRECT *)NULL;
+    command->flags |= CMD_INHIBIT_EXPANSION;
+    command->value.Simple->flags |= CMD_INHIBIT_EXPANSION;
+
+    result = execute_command (command);
+  }
+
+  run_unwind_frame ("jobs_builtin");
+  return (result);
+}
+#endif /* JOB_CONTROL */

builtins/kill.def

@@ -0,0 +1,281 @@
+This file is kill.def, from which is created kill.c.
+It implements the builtin "kill" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES kill.c
+
+$BUILTIN kill
+$FUNCTION kill_builtin
+$DEPENDS_ON JOB_CONTROL
+$SHORT_DOC kill [-s sigspec | -sigspec] [pid | job]... | -l [signum]
+Send the processes named by PID (or JOB) the signal SIGSPEC.  If
+SIGSPEC is not present, then SIGTERM is assumed.  An argument of `-l'
+lists the signal names; if arguments follow `-l' they are assumed to
+be signal numbers for which names should be listed.  Kill is a shell
+builtin for two reasons: it allows job IDs to be used instead of
+process IDs, and, if you have reached the limit on processes that
+you can create, you don't have to start a process to kill another one.
+$END
+
+/* Not all systems declare ERRNO in errno.h... and some systems #define it! */
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+
+#include "../bashtypes.h"
+#include "../shell.h"
+#include "../trap.h"
+#include "../jobs.h"
+#include "common.h"
+#include <errno.h>
+
+#if defined (JOB_CONTROL)
+extern int interactive;
+extern int posixly_correct;
+
+#if !defined (CONTINUE_AFTER_KILL_ERROR)
+#  define CONTINUE_OR_FAIL return (EXECUTION_FAILURE)
+#else
+#  define CONTINUE_OR_FAIL goto continue_killing
+#endif /* CONTINUE_AFTER_KILL_ERROR */
+
+/* Here is the kill builtin.  We only have it so that people can type
+   kill -KILL %1?  No, if you fill up the process table this way you
+   can still kill some. */
+int
+kill_builtin (list)
+     WORD_LIST *list;
+{
+  int signal = SIGTERM;
+  int any_succeeded = 0, listing = 0, saw_signal = 0;
+  char *sigspec = "TERM", *word;
+  pid_t pid;
+
+  if (!list)
+    return (EXECUTION_SUCCESS);
+
+  /* Process options. */
+  while (list)
+    {
+      word = list->word->word;
+
+      if (ISOPTION (word, 'l'))
+	{
+	  listing++;
+	  list = list->next;
+	}
+      else if (ISOPTION (word, 's'))
+	{
+	  list = list->next;
+	  if (list)
+	    {
+	      sigspec = list->word->word;
+	      if (sigspec[0] == '0' && !sigspec[1])
+		signal = 0;
+	      else
+		signal = decode_signal (sigspec);
+	      list = list->next;
+	    }
+	  else
+	    {
+	      builtin_error ("-s requires an argument");
+	      return (EXECUTION_FAILURE);
+	    }
+	}
+      else if (ISOPTION (word, '-'))
+	{
+	  list = list->next;
+	  break;
+	}
+      /* If this is a signal specification then process it.  We only process
+	 the first one seen; other arguments may signify process groups (e.g,
+	 -num == process group num). */
+      else if ((*word == '-') && !saw_signal)
+	{
+	  sigspec = word + 1;
+	  signal = decode_signal (sigspec);
+	  saw_signal++;
+	  list = list->next;
+	}
+      else
+	break;
+    }
+
+  if (listing)
+    {
+      if (!list)
+	{
+	  register int i;
+	  register int column = 0;
+	  char *name;
+
+	  for (i = 1; i < NSIG; i++)
+	    {
+	      name = signal_name (i);
+	      if (STREQN (name, "SIGJUNK", 7) || STREQN (name, "Unknown", 7))
+		continue;
+
+	      if (posixly_correct)
+	        printf ("%s%s", name, (i == NSIG - 1) ? "" : " ");
+	      else
+		{
+		  printf ("%2d) %s", i, name);
+
+		  if (++column < 4)
+		    printf ("\t");
+		  else
+		    {
+		      printf ("\n");
+		      column = 0;
+		    }
+		}
+	    }
+
+	  if (posixly_correct || column != 0)
+	    printf ("\n");
+	}
+      else
+	{
+	  /* List individual signal names. */
+	  while (list)
+	    {
+	      int signum;
+	      char *name;
+
+	      if ((sscanf (list->word->word, "%d", &signum) != 1) ||
+		  (signum <= 0))
+		{
+	    list_error:
+		  builtin_error ("bad signal number: %s", list->word->word);
+		  list = list->next;
+		  continue;
+		}
+
+	      /* This is specified by Posix.2 so that exit statuses can be
+		 mapped into signal numbers. */
+	      if (signum > 128)
+		signum -= 128;
+
+	      if (signum >= NSIG)
+		goto list_error;
+
+	      name = signal_name (signum);
+	      if (STREQN (name, "SIGJUNK", 7) || STREQN (name, "Unknown", 7))
+		{
+		  list = list->next;
+		  continue;
+		}
+	      printf ("%s\n", name);
+	      list = list->next;
+	    }
+	}
+      return (EXECUTION_SUCCESS);
+    }
+
+  /* OK, we are killing processes. */
+  if (signal == NO_SIG)
+    {
+      builtin_error ("bad signal spec `%s'", sigspec);
+      return (EXECUTION_FAILURE);
+    }
+
+  while (list)
+    {
+      word = list->word->word;
+
+      if (*word == '-')
+	word++;
+
+      if (all_digits (word))
+	{
+	  /* Use the entire argument in case of minus sign presence. */
+	  pid = (pid_t) atoi (list->word->word);
+
+	  if (kill_pid (pid, signal, 0) < 0)
+	    goto signal_error;
+	  else
+	    any_succeeded++;
+	}
+      else if (*list->word->word != '%')
+	{
+	  builtin_error ("No such pid %s", list->word->word);
+	  CONTINUE_OR_FAIL;
+	}
+#if 1
+      else if (interactive)
+	/* Posix.2 says you can kill without job control active (4.32.4) */
+#else
+      else if (job_control)	/* can't kill jobs if not using job control */
+#endif
+	{			/* Must be a job spec.  Check it out. */
+	  int job;
+	  sigset_t set, oset;
+
+	  BLOCK_CHILD (set, oset);
+	  job = get_job_spec (list);
+
+	  if (job < 0 || job >= job_slots || !jobs[job])
+	    {
+	      if (job != DUP_JOB)
+		builtin_error ("No such job %s", list->word->word);
+	      UNBLOCK_CHILD (oset);
+	      CONTINUE_OR_FAIL;
+	    }
+
+	  /* Job spec used.  Kill the process group. If the job was started
+	     without job control, then its pgrp == shell_pgrp, so we have
+	     to be careful.  We take the pid of the first job in the pipeline
+	     in that case. */
+	  if (jobs[job]->flags & J_JOBCONTROL)
+	    pid = jobs[job]->pgrp;
+	  else
+	    pid = jobs[job]->pipe->pid;
+
+	  UNBLOCK_CHILD (oset);
+
+	  if (kill_pid (pid, signal, 1) < 0)
+	    {
+	    signal_error:
+	      if (errno == EPERM)
+		builtin_error ("(%d) - Not owner", (int)pid);
+	      else if (errno == ESRCH)
+		builtin_error ("(%d) - No such pid", (int)pid);
+	      else
+		builtin_error ("Invalid signal %d", signal);
+	      CONTINUE_OR_FAIL;
+	    }
+	  else
+	    any_succeeded++;
+	}
+      else
+	{
+	  builtin_error ("bad process specification `%s'", list->word->word);
+	  CONTINUE_OR_FAIL;
+	}
+    continue_killing:
+      list = list->next;
+    }
+
+  if (any_succeeded)
+    return (EXECUTION_SUCCESS);
+  else
+    return (EXECUTION_FAILURE);
+}
+#endif /* JOB_CONTROL */

builtins/let.def

@@ -0,0 +1,77 @@
+This file is let.def, from which is created let.c.
+It implements the builtin "let" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$BUILTIN let
+$FUNCTION let_builtin
+$PRODUCES let.c
+$SHORT_DOC let arg [arg ...]
+Each ARG is an arithmetic expression to be evaluated.  Evaluation
+is done in long integers with no check for overflow, though division
+by 0 is trapped and flagged as an error.  The following list of
+operators is grouped into levels of equal-precedence operators.
+The levels are listed in order of decreasing precedence.
+
+	-		unary minus
+	!		logical NOT
+	* / %		multiplication, division, remainder
+	+ -		addition, subtraction
+	<= >= < >	comparison
+	== !=		equality inequality
+	=		assignment
+
+Shell variables are allowed as operands.  The name of the variable
+is replaced by its value (coerced to a long integer) within
+an expression.  The variable need not have its integer attribute
+turned on to be used in an expression.
+
+Operators are evaluated in order of precedence.  Sub-expressions in
+parentheses are evaluated first and may override the precedence
+rules above.
+
+If the last ARG evaluates to 0, let returns 1; 0 is returned
+otherwise.
+$END
+
+#include "../shell.h"
+
+/* Arithmetic LET function. */
+let_builtin (list)
+     WORD_LIST *list;
+{
+  long ret = 0L;
+
+  if (!list)
+    {
+      builtin_error ("argument (expression) expected");
+      return (EXECUTION_FAILURE);
+    }
+
+  while (list)
+    {
+      ret = evalexp (list->word->word);
+      list = list->next;
+    }
+
+  if (ret == 0L)
+    return (EXECUTION_FAILURE);
+  else
+    return (EXECUTION_SUCCESS);
+}

builtins/psize.c

@@ -0,0 +1,63 @@
+/* psize.c - Find pipe size. */
+
+/* Copyright (C) 1987, 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/*  Write output in 128-byte chunks until we get a sigpipe or write gets an
+    EPIPE.  Then report how many bytes we wrote.  We assume that this is the
+    pipe size. */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+
+#include "../command.h"
+#include "../general.h"
+extern int errno;
+
+int nw;
+
+sighandler
+sigpipe (sig)
+     int sig;
+{
+  fprintf (stderr, "%d\n", nw);
+  exit (0);
+}
+
+main (argc, argv)
+     int argc;
+     char **argv;
+{
+  char buf[128];
+  register int i;
+
+  for (i = 0; i < 128; i++)
+    buf[i] = ' ';
+
+  signal (SIGPIPE, sigpipe);
+
+  nw = 0;
+  for (;;)
+    {
+      int n;
+      n = write (1, buf, 128);
+      nw += n;
+    }
+}

builtins/psize.sh

@@ -0,0 +1,24 @@
+#! /bin/sh
+#
+# psize.sh -- determine this system's pipe size, and write a define to
+#             pipesize.h so ulimit.c can use it.
+
+echo "/*"
+echo " * pipesize.h"
+echo " *"
+echo " * This file is automatically generated by psize.sh"
+echo " * Do not edit!"
+echo " */"
+echo ""
+
+./psize.aux 2>/tmp/pipesize | sleep 3
+
+if [ -s /tmp/pipesize ]; then
+	echo "#define PIPESIZE `cat /tmp/pipesize`"
+else
+	echo "#define PIPESIZE 512"
+fi
+
+rm -f /tmp/pipesize
+
+exit 0

builtins/read.def

@@ -0,0 +1,276 @@
+This file is read.def, from which is created read.c.
+It implements the builtin "read" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES read.c
+
+$BUILTIN read
+$FUNCTION read_builtin
+$SHORT_DOC read [-r] [name ...]
+One line is read from the standard input, and the first word is
+assigned to the first NAME, the second word to the second NAME, etc.
+with leftover words assigned to the last NAME.  Only the characters
+found in $IFS are recognized as word delimiters.  The return code is
+zero, unless end-of-file is encountered.  If the -r option is given,
+this signifies `raw' input, and backslash processing is disabled.
+$END
+
+#include <stdio.h>
+#include "../shell.h"
+#include "common.h"
+
+#define issep(c)	(strchr (ifs_chars, (c)) != (char *)0)
+
+static int stream_close ();
+
+extern int interrupt_immediately;
+
+/* Read the value of the shell variables whose names follow.
+   The reading is done from the current input stream, whatever
+   that may be.  Successive words of the input line are assigned
+   to the variables mentioned in LIST.  The last variable in LIST
+   gets the remainder of the words on the line.  If no variables
+   are mentioned in LIST, then the default variable is $REPLY.
+
+   S. R. Bourne's shell complains if you don't name a variable
+   to receive the stuff that is read.  GNU's shell doesn't.  This
+   allows you to let the user type random things. */
+read_builtin (list)
+     WORD_LIST *list;
+{
+  register char *varname;
+  int size, c, i, fildes, raw_mode, pass_next, saw_escape, retval;
+  char *input_string, *orig_input_string, *ifs_chars, *t;
+  FILE *input_stream;
+  SHELL_VAR *var;
+
+  i = 0;		/* Index into the string that we are reading. */
+  raw_mode = 0;		/* Not reading raw input be default. */
+
+  while (list)
+    {
+      if (ISOPTION (list->word->word, 'r'))
+	{
+	  raw_mode = 1;
+	  list = list->next;
+	}
+      else if (ISOPTION (list->word->word, '-'))
+	{
+	  list = list->next;
+	  break;
+	}
+      else if (*list->word->word == '-')
+	{
+	  bad_option (list->word->word);
+	  builtin_error ("usage: read [-r] [name ...]");
+	  return (EX_USAGE);
+	}
+      else
+	break;
+    }
+
+  /* We need unbuffered input from stdin.  So we make a new stream with
+     the same file descriptor as stdin, then unbuffer it. */
+  fildes = dup (fileno (stdin));
+
+  if (fildes == -1)
+    return (EXECUTION_FAILURE);
+
+  input_stream = fdopen (fildes, "r");
+
+  if (!input_stream)
+    {
+      close (fildes);
+      return (EXECUTION_FAILURE);
+    }
+
+  var = find_variable ("IFS");
+  ifs_chars = var ? value_cell (var) : " \t\n";
+  
+  input_string = xmalloc (size = 128);
+
+  setbuf (input_stream, (char *)NULL);
+
+  begin_unwind_frame ("read_builtin");
+  add_unwind_protect (xfree, input_string);
+  add_unwind_protect (stream_close, input_stream);
+  interrupt_immediately++;
+
+  pass_next = 0;	/* Non-zero signifies last char was backslash. */
+  saw_escape = 0;	/* Non-zero signifies that we saw an escape char */
+
+  while ((c = getc (input_stream)) != EOF)
+    {
+      if (i + 2 >= size)
+	input_string = xrealloc (input_string, size += 128);
+
+      /* If the next character is to be accepted verbatim, a backslash
+	 newline pair still disappears from the input. */
+      if (pass_next)
+	{
+	  if (c == '\n')
+	    i--;		/* back up over the CTLESC */
+	  else
+	    input_string[i++] = c;
+	  pass_next = 0;
+	  continue;
+	}
+
+      if (c == '\\' && !raw_mode)
+	{
+	  pass_next++;
+	  saw_escape++;
+	  input_string[i++] = CTLESC;
+	  continue;
+	}
+
+      if (c == '\n')
+	break;
+
+      if (c == CTLESC || c == CTLNUL)
+	{
+	  saw_escape++;
+	  input_string[i++] = CTLESC;
+	}
+
+      input_string[i++] = c;
+    }
+  input_string[i] = '\0';
+
+  interrupt_immediately--;
+  discard_unwind_frame ("read_builtin");
+
+  fclose (input_stream);
+
+  if (c == EOF)
+    {
+      retval = EXECUTION_FAILURE;
+      /* input_string[0] = '\0'; */
+    }
+  else
+    retval = EXECUTION_SUCCESS;
+
+  if (!list)
+    {
+      if (saw_escape)
+	{
+	  t = dequote_string (input_string);
+	  var = bind_variable ("REPLY", t);
+	  free (t);
+	}
+      else
+	var = bind_variable ("REPLY", input_string);
+      var->attributes &= ~att_invisible;
+      free (input_string);
+    }
+  else
+    {
+      /* This code implements the Posix.2 spec for splitting the words
+	 read and assigning them to variables.  If $IFS is unset, we
+	 use the default value of " \t\n". */
+      orig_input_string = input_string;
+
+      /* Remove IFS white space at the beginning of the input string.  If
+	 $IFS is null, no field splitting is performed. */
+      for (t = input_string; *ifs_chars && spctabnl (*t) && issep (*t); t++)
+	;
+      input_string = t;
+
+      for (; list->next; list = list->next)
+	{
+	  char *e, *t1;
+
+	  varname = list->word->word;
+	  if (legal_identifier (varname) == 0)
+	    {
+	      builtin_error ("%s: not a legal variable name", varname);
+	      free (orig_input_string);
+	      return (EXECUTION_FAILURE);
+	    }
+
+	  /* If there are more variables than words read from the input,
+	     the remaining variables are set to the empty string. */
+	  if (*input_string)
+	    {
+	      /* This call updates INPUT_STRING. */
+	      t = get_word_from_string (&input_string, ifs_chars, &e);
+	      if (t)
+		*e = '\0';
+	      /* Don't bother to remove the CTLESC unless we added one
+		 somewhere while reading the string. */
+	      if (t && saw_escape)
+		{
+		  t1 = dequote_string (t);
+		  var = bind_variable (varname, t1);
+		  free (t1);
+		}
+	      else
+		var = bind_variable (varname, t);
+	    }
+	  else
+	    {
+	      t = (char *)0;
+	      var = bind_variable (varname, "");
+	    }
+
+	  stupidly_hack_special_variables (varname);
+	  var->attributes &= ~att_invisible;
+
+	  if (t)
+	    free (t);
+	}
+
+      if (legal_identifier (list->word->word) == 0)
+	{
+	  builtin_error ("%s: not a legal variable name", list->word->word);
+	  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);
+	  var = bind_variable (list->word->word, t);
+	  free (t);
+	}
+      else
+	var = bind_variable (list->word->word, input_string);
+      stupidly_hack_special_variables (list->word->word);
+      var->attributes &= ~att_invisible;
+      free (orig_input_string);
+    }
+
+  return (retval);
+}
+
+/* This way I don't have to know whether fclose () is a
+   function or a macro. */
+static int
+stream_close (file)
+     FILE *file;
+{
+  return (fclose (file));
+}

builtins/reserved.def

@@ -0,0 +1,154 @@
+This file is reserved.def, in which the shell reserved words are defined.
+It has no direct C file production, but defines builtins for the Bash
+builtin help command.
+
+Copyright (C) 1987, 1989, 1991, 1992 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$BUILTIN for
+$SHORT_DOC for NAME [in WORDS ... ;] do COMMANDS; done
+The `for' loop executes a sequence of commands for each member in a
+list of items.  If `in WORDS ...;' is not present, then `in "$@"' is
+assumed.  For each element in WORDS, NAME is set to that element, and
+the COMMANDS are executed.
+$END
+
+$BUILTIN select
+$SHORT_DOC select NAME [in WORDS ... ;] do COMMANDS; done
+The WORDS are expanded, generating a list of words.  The
+set of expanded words is printed on the standard error, each
+preceded by a number.  If `in WORDS' is not present, `in "$@"'
+is assumed.  The PS3 prompt is then displayed and a line read
+from the standard input.  If the line consists of the number
+corresponding to one of the displayed words, then NAME is set
+to that word.  If the line is empty, WORDS and the prompt are
+redisplayed.  If EOF is read, the command completes.  Any other
+value read causes NAME to be set to null.  The line read is saved
+in the variable REPLY.  COMMANDS are executed after each selection
+until a break or return command is executed.
+$END
+
+$BUILTIN case
+$SHORT_DOC case WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esac
+Selectively execute COMMANDS based upon WORD matching PATTERN.  The
+`|' is used to separate multiple patterns.
+$END
+
+$BUILTIN if
+$SHORT_DOC if COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS; ]... [ else COMMANDS; ] fi
+The if COMMANDS are executed.  If the exit status is zero, then the then
+COMMANDS are executed.  Otherwise, each of the elif COMMANDS are executed
+in turn, and if the exit status is zero, the corresponding then COMMANDS
+are executed and the if command completes.  Otherwise, the else COMMANDS
+are executed, if present.  The exit status is the exit status of the last
+command executed, or zero if no condition tested true.
+$END
+
+$BUILTIN while
+$SHORT_DOC while COMMANDS; do COMMANDS; done
+Expand and execute COMMANDS as long as the final command in the
+`while' COMMANDS has an exit status of zero.
+$END
+
+$BUILTIN until
+$SHORT_DOC until COMMANDS; do COMMANDS; done
+Expand and execute COMMANDS as long as the final command in the
+`until' COMMANDS has an exit status which is not zero.
+$END
+
+$BUILTIN function
+$SHORT_DOC function NAME { COMMANDS ; } or NAME () { COMMANDS ; }
+Create a simple command invoked by NAME which runs COMMANDS.
+Arguments on the command line along with NAME are passed to the
+function as $0 .. $n.
+$END
+
+$BUILTIN { ... }
+$DOCNAME grouping_braces
+$SHORT_DOC { COMMANDS }
+Run a set of commands in a group.  This is one way to redirect an
+entire set of commands.
+$END
+
+$BUILTIN %
+$DOCNAME fg_percent
+$SHORT_DOC %[DIGITS | WORD] [&]
+This is similar to the `fg' command.  Resume a stopped or background
+job.  If you specifiy DIGITS, then that job is used.  If you specify
+WORD, then the job whose name begins with WORD is used.  Following the
+job specification with a `&' places the job in the background.
+$END
+
+$BUILTIN variables
+$DOCNAME variable_help
+$SHORT_DOC variables - Some variable names and meanings
+BASH_VERSION    The version numbers of this Bash.
+CDPATH          A colon separated list of directories to search
+		when the argument to `cd' is not found in the current
+		directory.
+#if defined (HISTORY)
+HISTFILE        The name of the file where your command history is stored.
+HISTFILESIZE    The maximum number of lines this file can contain.
+HISTSIZE        The maximum number of history lines that a running
+		shell can access.
+#endif /* HISTORY */
+HOME            The complete pathname to your login directory.
+HOSTTYPE        The type of CPU this version of Bash is running under.
+IGNOREEOF       Controls the action of the shell on receipt of an EOF
+		character as the sole input.  If set, then the value
+		of it is the number of EOF characters that can be seen
+		in a row on an empty line before the shell will exit
+		(default 10).  When unset, EOF signifies the end of input.
+MAILCHECK	How often, in seconds, Bash checks for new mail.
+MAILPATH	A colon-separated list of filenames which Bash checks
+		for new mail.
+PATH            A colon-separated list of directories to search when
+		looking for commands.
+PROMPT_COMMAND  A command to be executed before the printing of each
+		primary prompt.
+PS1             The primary prompt string.
+PS2             The secondary prompt string.
+TERM            The name of the current terminal type.
+auto_resume     Non-null means a command word appearing on a line by
+		itself is first looked for in the list of currently
+		stopped jobs.  If found there, that job is foregrounded.
+		A value of `exact' means that the command word must
+		exactly match a command in the list of stopped jobs.  A
+		value of `substring' means that the command word must
+		match a substring of the job.  Any other value means that
+		the command must be a prefix of a stopped job.
+#if defined (HISTORY)
+command_oriented_history
+                Non-null means to save multiple-line commands together on
+                a single history line.
+#  if defined (BANG_HISTORY)
+histchars       Characters controlling history expansion and quick
+		substitution.  The first character is the history
+		substitution character, usually `!'.  The second is
+		the `quick substitution' character, usually `^'.  The
+		third is the `history comment' character, usually `#'.
+#  endif /* BANG_HISTORY */
+HISTCONTROL	Set to a value of `ignorespace', it means don't enter
+		lines which begin with a space or tab on the history
+		list.  Set to a value of `ignoredups', it means don't
+		enter lines which match the last entered line.  Set to
+		`ignoreboth' means to combine the two options.  Unset,
+		or set to any other value than those above means to save
+		all lines on the history list.
+#endif /* HISTORY */
+$END

builtins/return.def

@@ -0,0 +1,57 @@
+This file is return.def, from which is created return.c.
+It implements the builtin "return" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES return.c
+
+$BUILTIN return
+
+$FUNCTION return_builtin
+$SHORT_DOC return [n]
+Causes a function to exit with the return value specified by N.  If N
+is omitted, the return status is that of the last command.
+$END
+
+#include "../shell.h"
+
+extern int last_command_exit_value;
+extern int return_catch_flag, return_catch_value;
+extern jmp_buf return_catch;
+
+/* If we are executing a user-defined function then exit with the value
+   specified as an argument.  if no argument is given, then the last
+   exit status is used. */
+int
+return_builtin (list)
+     WORD_LIST *list;
+{
+  return_catch_value = get_numeric_arg (list);
+
+  if (!list)
+    return_catch_value = last_command_exit_value;
+
+  if (return_catch_flag)
+    longjmp (return_catch, 1);
+  else
+    {
+      builtin_error ("Can only `return' from a function");
+      return (EXECUTION_FAILURE);
+    }
+}

builtins/set.def

@@ -0,0 +1,528 @@
+This file is set.def, from which is created set.c.
+It implements the "set" and "unset" builtins 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES set.c
+
+#include <stdio.h>
+#include "../shell.h"
+#include "../flags.h"
+
+#include "bashgetopt.h"
+
+extern int interactive;
+extern int noclobber, no_brace_expansion, posixly_correct;
+#if defined (READLINE)
+extern int rl_editing_mode, no_line_editing;
+#endif /* READLINE */
+
+#define USAGE_STRING "set [--abefhknotuvxldHCP] [-o option] [arg ...]"
+
+$BUILTIN set
+$FUNCTION set_builtin
+$SHORT_DOC set [--abefhknotuvxldHCP] [-o option] [arg ...]
+    -a  Mark variables which are modified or created for export.
+    -b  Notify of job termination immediately.
+    -e  Exit immediately if a command exits with a non-zero status.
+    -f  Disable file name generation (globbing).
+    -h  Locate and remember function commands as functions are
+        defined.  Function commands are normally looked up when
+        the function is executed.
+    -i  Force the shell to be an "interactive" one.  Interactive shells
+        always read `~/.bashrc' on startup.
+    -k  All keyword arguments are placed in the environment for a
+        command, not just those that precede the command name.
+    -m  Job control is enabled.
+    -n  Read commands but do not execute them.
+    -o option-name
+        Set the variable corresponding to option-name:
+            allexport    same as -a
+            braceexpand  the shell will perform brace expansion
+#if defined (READLINE)
+            emacs        use an emacs-style line editing interface
+#endif /* READLINE */
+            errexit      same as -e
+#if defined (BANG_HISTORY)
+            histexpand   same as -H
+#endif /* BANG_HISTORY */
+            ignoreeof    the shell will not exit upon reading EOF
+            interactive-comments
+                         allow comments to appear in interactive commands
+            monitor      same as -m
+            noclobber    disallow redirection to existing files
+            noexec       same as -n
+            noglob       same as -f
+            nohash       same as -d
+            notify       save as -b
+            nounset      same as -u
+	    physical     same as -P
+	    posix        change the behavior of bash where the default
+			 operation differs from the 1003.2 standard to
+			 match the standard
+	    privileged   same as -p
+            verbose      same as -v
+#if defined (READLINE)
+            vi           use a vi-style line editing interface
+#endif /* READLINE */
+            xtrace       same as -x
+    -p  Turned on whenever the real and effective user ids do not match.
+        Disables processing of the $ENV file and importing of shell
+        functions.  Turning this option off causes the effective uid and
+	gid to be set to the real uid and gid.
+    -t  Exit after reading and executing one command.
+    -u  Treat unset variables as an error when substituting.
+    -v  Print shell input lines as they are read.
+    -x  Print commands and their arguments as they are executed.
+    -l  Save and restore the binding of the NAME in a FOR command.
+    -d  Disable the hashing of commands that are looked up for execution.
+        Normally, commands are remembered in a hash table, and once
+        found, do not have to be looked up again.
+#if defined (BANG_HISTORY)
+    -H  Enable ! style history substitution.  This flag is on
+        by default.
+#endif /* BANG_HISTORY */
+    -C  If set, disallow existing regular files to be overwritten
+        by redirection of output.
+    -P  If set, do not follow symbolic links when executing commands
+        such as cd which change the current directory.
+
+Using + rather than - causes these flags to be turned off.  The
+flags can also be used upon invocation of the shell.  The current
+set of flags may be found in $-.  The remaining n ARGs are positional
+parameters and are assigned, in order, to $1, $2, .. $n.  If no
+ARGs are given, all shell variables are printed.
+$END
+
+/* An a-list used to match long options for set -o to the corresponding
+   option letter. */
+struct {
+  char *name;
+  int letter;
+} o_options[] = {
+  { "allexport",  'a' },
+  { "errexit",	  'e' },
+#if defined (BANG_HISTORY)
+  { "histexpand", 'H' },
+#endif /* BANG_HISTORY */
+  { "monitor",	  'm' },
+  { "noexec",	  'n' },
+  { "noglob",	  'f' },
+  { "nohash",	  'd' },
+#if defined (JOB_CONTROL)
+  { "notify",	  'b' },
+#endif /* JOB_CONTROL */
+  {"nounset",	  'u' },
+  {"physical",    'P' },
+  {"privileged",  'p' },
+  {"verbose",	  'v' },
+  {"xtrace",	  'x' },
+  {(char *)NULL, 0},
+};
+
+#define MINUS_O_FORMAT "%-15s\t%s\n"
+
+void
+list_minus_o_opts ()
+{
+  register int	i;
+  char *on = "on", *off = "off";
+
+  printf (MINUS_O_FORMAT, "braceexpand", (no_brace_expansion == 0) ? on : off);
+  printf (MINUS_O_FORMAT, "noclobber", (noclobber == 1) ? on : off);
+
+  if (find_variable ("ignoreeof") || find_variable ("IGNOREEOF"))
+    printf (MINUS_O_FORMAT, "ignoreeof", on);
+  else
+    printf (MINUS_O_FORMAT, "ignoreeof", off);
+
+  printf (MINUS_O_FORMAT, "interactive-comments",
+	  interactive_comments ? on : off);
+
+  printf (MINUS_O_FORMAT, "posix", posixly_correct ? on : off);
+
+#if defined (READLINE)
+  if (no_line_editing)
+    {
+      printf (MINUS_O_FORMAT, "emacs", off);
+      printf (MINUS_O_FORMAT, "vi", off);
+    }
+  else
+    {
+      /* Magic.  This code `knows' how readline handles rl_editing_mode. */
+      printf (MINUS_O_FORMAT, "emacs", (rl_editing_mode == 1) ? on : off);
+      printf (MINUS_O_FORMAT, "vi", (rl_editing_mode == 0) ? on : off);
+    }
+#endif /* READLINE */
+
+  for (i = 0; o_options[i].name; i++)
+    {
+      int *on_or_off, zero = 0;
+
+      on_or_off = find_flag (o_options[i].letter);
+      if (on_or_off == FLAG_UNKNOWN)
+	on_or_off = &zero;
+      printf (MINUS_O_FORMAT, o_options[i].name, (*on_or_off == 1) ? on : off);
+    }
+}
+
+set_minus_o_option (on_or_off, option_name)
+     int on_or_off;
+     char *option_name;
+{
+  int option_char = -1;
+
+  if (STREQ (option_name, "braceexpand"))
+    {
+      if (on_or_off == FLAG_ON)
+	no_brace_expansion = 0;
+      else
+	no_brace_expansion = 1;
+    }
+  else if (STREQ (option_name, "noclobber"))
+    {
+      if (on_or_off == FLAG_ON)
+	bind_variable ("noclobber", "");
+      else
+	unbind_variable ("noclobber");
+      stupidly_hack_special_variables ("noclobber");
+    }
+  else if (STREQ (option_name, "ignoreeof"))
+    {
+      unbind_variable ("ignoreeof");
+      unbind_variable ("IGNOREEOF");
+      if (on_or_off == FLAG_ON)
+	bind_variable ("IGNOREEOF", "10");
+      stupidly_hack_special_variables ("IGNOREEOF");
+    }
+  
+#if defined (READLINE)
+  else if ((STREQ (option_name, "emacs")) || (STREQ (option_name, "vi")))
+    {
+      if (on_or_off == FLAG_ON)
+	{
+	  rl_variable_bind ("editing-mode", option_name);
+
+	  if (interactive)
+	    with_input_from_stdin ();
+	  no_line_editing = 0;
+	}
+      else
+	{
+	  int isemacs = (rl_editing_mode == 1);
+	  if ((isemacs && STREQ (option_name, "emacs")) ||
+	      (!isemacs && STREQ (option_name, "vi")))
+	    {
+	      if (interactive)
+		with_input_from_stream (stdin, "stdin");
+	      no_line_editing = 1;
+	    }
+	  else
+	    builtin_error ("not in %s editing mode", option_name);
+	}
+    }
+#endif /* READLINE */
+  else if (STREQ (option_name, "interactive-comments"))
+    interactive_comments = (on_or_off == FLAG_ON);
+  else if (STREQ (option_name, "posix"))
+    {
+      posixly_correct = (on_or_off == FLAG_ON);
+      unbind_variable ("POSIXLY_CORRECT");
+      unbind_variable ("POSIX_PEDANTIC");
+      if (on_or_off == FLAG_ON)
+	{
+	  bind_variable ("POSIXLY_CORRECT", "");
+	  stupidly_hack_special_variables ("POSIXLY_CORRECT");
+	}
+    }
+  else
+    {
+      register int i;
+      for (i = 0; o_options[i].name; i++)
+	{
+	  if (STREQ (option_name, o_options[i].name))
+	    {
+	      option_char = o_options[i].letter;
+	      break;
+	    }
+	}
+      if (option_char == -1)
+	{
+	  builtin_error ("%s: unknown option name", option_name);
+	  return (EXECUTION_FAILURE);
+	}
+      if (change_flag (option_char, on_or_off) == FLAG_ERROR)
+	{
+	  bad_option (option_name);
+	  return (EXECUTION_FAILURE);
+	}
+    }
+  return (EXECUTION_SUCCESS);
+}
+
+/* Set some flags from the word values in the input list.  If LIST is empty,
+   then print out the values of the variables instead.  If LIST contains
+   non-flags, then set $1 - $9 to the successive words of LIST. */
+set_builtin (list)
+     WORD_LIST *list;
+{
+  int on_or_off, flag_name, force_assignment = 0;
+
+  if (!list)
+    {
+      SHELL_VAR **vars;
+
+      vars = all_shell_variables ();
+      if (vars)
+	{
+	  print_var_list (vars);
+	  free (vars);
+	}
+
+      vars = all_shell_functions ();
+      if (vars)
+	{
+	  print_var_list (vars);
+	  free (vars);
+	}
+
+      return (EXECUTION_SUCCESS);
+    }
+
+  /* Check validity of flag arguments. */
+  if (*list->word->word == '-' || *list->word->word == '+')
+    {
+      register char *arg;
+      WORD_LIST *save_list = list;
+
+      while (list && (arg = list->word->word))
+	{
+	  char c;
+
+	  if (arg[0] != '-' && arg[0] != '+')
+	    break;
+
+	  /* `-' or `--' signifies end of flag arguments. */
+	  if (arg[0] == '-' &&
+	      (!arg[1] || (arg[1] == '-' && !arg[2])))
+	    break;
+
+	  while (c = *++arg)
+	    {
+	      if (find_flag (c) == FLAG_UNKNOWN && c != 'o')
+		{
+		  char s[2];
+		  s[0] = c; s[1] = '\0';
+		  bad_option (s);
+		  if (c == '?')
+		    printf ("usage: %s\n", USAGE_STRING);
+		  return (c == '?' ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
+		}
+	    }
+	  list = list->next;
+	}
+      list = save_list;
+    }
+
+  /* Do the set command.  While the list consists of words starting with
+     '-' or '+' treat them as flags, otherwise, start assigning them to
+     $1 ... $n. */
+  while (list)
+    {
+      char *string = list->word->word;
+
+      /* If the argument is `--' or `-' then signal the end of the list
+	 and remember the remaining arguments. */
+      if (string[0] == '-' && (!string[1] || (string[1] == '-' && !string[2])))
+	{
+	  list = list->next;
+
+	  /* `set --' unsets the positional parameters. */
+	  if (string[1] == '-')
+	    force_assignment = 1;
+
+	  /* Until told differently, the old shell behaviour of
+	     `set - [arg ...]' being equivalent to `set +xv [arg ...]'
+	     stands.  Posix.2 says the behaviour is marked as obsolescent. */
+	  else
+	    {
+	      change_flag ('x', '+');
+	      change_flag ('v', '+');
+	    }
+
+	  break;
+	}
+
+      if ((on_or_off = *string) &&
+	  (on_or_off == '-' || on_or_off == '+'))
+	{
+	  int i = 1;
+	  while (flag_name = string[i++])
+	    {
+	      if (flag_name == '?')
+		{
+		  printf ("usage: %s\n", USAGE_STRING);
+		  return (EXECUTION_SUCCESS);
+		}
+	      else if (flag_name == 'o') /* -+o option-name */
+		{
+		  char *option_name;
+		  WORD_LIST *opt;
+
+		  opt = list->next;
+
+		  if (!opt)
+		    {
+		      list_minus_o_opts ();
+		      continue;
+		    }
+
+		  option_name = opt->word->word;
+
+		  if (!option_name || !*option_name || (*option_name == '-'))
+		    {
+		      list_minus_o_opts ();
+		      continue;
+		    }
+		  list = list->next; /* Skip over option name. */
+
+		  if (set_minus_o_option (on_or_off, option_name) != EXECUTION_SUCCESS)
+		    return (EXECUTION_FAILURE);
+		}
+	      else
+		{
+		  if (change_flag (flag_name, on_or_off) == FLAG_ERROR)
+		    {
+		      char opt[3];
+		      opt[0] = on_or_off;
+		      opt[1] = flag_name;
+		      opt[2] = '\0';
+		      bad_option (opt);
+		      return (EXECUTION_FAILURE);
+		    }
+		}
+	    }
+	}
+      else
+	{
+	  break;
+	}
+      list = list->next;
+    }
+
+  /* Assigning $1 ... $n */
+  if (list || force_assignment)
+    remember_args (list, 1);
+  return (EXECUTION_SUCCESS);
+}
+
+$BUILTIN unset
+$FUNCTION unset_builtin
+$SHORT_DOC unset [-f] [-v] [name ...]
+For each NAME, remove the corresponding variable or function.  Given
+the `-v', unset will only act on variables.  Given the `-f' flag,
+unset will only act on functions.  With neither flag, unset first
+tries to unset a variable, and if that fails, then tries to unset a
+function.  Some variables (such as PATH and IFS) cannot be unset; also
+see readonly.
+$END
+
+unset_builtin (list)
+  WORD_LIST *list;
+{
+  int unset_function = 0, unset_variable = 0, opt;
+  int any_failed = 0;
+  char *name;
+
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, "fv")) != -1)
+    {
+      switch (opt)
+	{
+	case 'f':
+	  unset_function = 1;
+	  break;
+	case 'v':
+	  unset_variable = 1;
+	  break;
+	default:
+	  return (EXECUTION_FAILURE);
+	}
+    }
+
+  list = loptend;
+
+  if (unset_function && unset_variable)
+    {
+      builtin_error ("cannot simultaneously unset a function and a variable");
+      return (EXECUTION_FAILURE);
+    }
+
+  while (list)
+    {
+      name = list->word->word;
+
+      if (!unset_function &&
+	  find_name_in_list (name, non_unsettable_vars) > -1)
+	{
+	  builtin_error ("%s: cannot unset", name);
+	  any_failed++;
+	}
+      else
+	{
+	  SHELL_VAR *var;
+	  int tem;
+
+	  var = unset_function ? find_function (name) : find_variable (name);
+
+	  /* Posix.2 says that unsetting readonly variables is an error. */
+	  if (var && readonly_p (var))
+	    {
+	      builtin_error ("%s: cannot unset: readonly %s",
+			     name, unset_function ? "function" : "variable");
+	      any_failed++;
+	      list = list->next;
+	      continue;
+	    }
+
+	  /* Unless the -f option is supplied, the name refers to a
+	     variable. */
+	  tem = makunbound
+	    (name, unset_function ? shell_functions : shell_variables);
+
+	  /* This is what Posix.2 draft 11+ says.  ``If neither -f nor -v
+	     is specified, the name refers to a variable; if a variable by
+	     that name does not exist, a function by that name, if any,
+	     shall be unset.'' */
+	  if ((tem == -1) && !unset_function && !unset_variable)
+	    tem = makunbound (name, shell_functions);
+
+	  if (tem == -1)
+	    any_failed++;
+	  else if (!unset_function)
+	    stupidly_hack_special_variables (name);
+	}
+      list = list->next;
+    }
+
+  if (any_failed)
+    return (EXECUTION_FAILURE);
+  else
+    return (EXECUTION_SUCCESS);
+}

builtins/setattr.def

@@ -0,0 +1,253 @@
+This file is setattr.def, from which is created setattr.c.
+It implements the builtins "export" and "readonly", 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES setattr.c
+
+#include "../shell.h"
+#include "common.h"
+#include "bashgetopt.h"
+
+extern int array_needs_making;
+extern char *this_command_name;
+
+$BUILTIN export
+$FUNCTION export_builtin
+$SHORT_DOC export [-n] [-f] [name ...] or export -p
+NAMEs are marked for automatic export to the environment of
+subsequently executed commands.  If the -f option is given,
+the NAMEs refer to functions.  If no NAMEs are given, or if `-p'
+is given, a list of all names that are exported in this shell is
+printed.  An argument of `-n' says to remove the export property
+from subsequent NAMEs.  An argument of `--' disables further option
+processing.
+$END
+
+/* For each variable name in LIST, make that variable appear in the
+   environment passed to simple commands.  If there is no LIST, then
+   print all such variables.  An argument of `-n' says to remove the
+   exported attribute from variables named in LIST.  An argument of
+  -f indicates that the names present in LIST refer to functions. */
+export_builtin (list)
+     register WORD_LIST *list;
+{
+  return (set_or_show_attributes (list, att_exported));
+}
+
+$BUILTIN readonly
+$FUNCTION readonly_builtin
+$SHORT_DOC readonly [-n] [-f] [name ...] or readonly -p
+The given NAMEs are marked readonly and the values of these NAMEs may
+not be changed by subsequent assignment.  If the -f option is given,
+then functions corresponding to the NAMEs are so marked.  If no
+arguments are given, or if `-p' is given, a list of all readonly names
+is printed.  An argument of `-n' says to remove the readonly property
+from subsequent NAMEs.  An argument of `--' disables further option
+processing.
+$END
+
+/* For each variable name in LIST, make that variable readonly.  Given an
+   empty LIST, print out all existing readonly variables. */
+readonly_builtin (list)
+     register WORD_LIST *list;
+{
+  return (set_or_show_attributes (list, att_readonly));
+}
+
+/* For each variable name in LIST, make that variable have the specified
+   ATTRIBUTE.  An arg of `-n' says to remove the attribute from the the
+   remaining names in LIST. */
+int
+set_or_show_attributes (list, attribute)
+     register WORD_LIST *list;
+     int attribute;
+{
+  register SHELL_VAR *var;
+  int assign, undo = 0, functions_only = 0, any_failed = 0, opt;
+
+  /* Read arguments from the front of the list. */
+  reset_internal_getopt ();
+  while ((opt = internal_getopt (list, "nfp")) != -1)
+    {
+      switch (opt)
+	{
+	  case 'n':
+	    undo = 1;
+	    break;
+	  case 'f':
+	    functions_only = 1;
+	    break;
+	  case 'p':
+	    break;
+	  default:
+	    builtin_error ("usage: %s [-nfp] [varname]", this_command_name);
+	    return (EX_USAGE);
+	}
+    }
+  list = loptend;
+
+  if (list)
+    {
+      if (attribute & att_exported)
+	array_needs_making = 1;
+
+      /* Cannot undo readonly status. */
+      if (undo && (attribute & att_readonly))
+	attribute &= ~att_readonly;
+
+      while (list)
+	{
+	  register char *name = list->word->word;
+
+	  if (functions_only)
+	    {
+	      var = find_function (name);
+	      if (!var)
+		{
+		  builtin_error ("%s: not a function", name);
+		  any_failed++;
+		}
+	      else
+		{
+		  if (undo)
+		    var->attributes &= ~attribute;
+		  else
+		    var->attributes |= attribute;
+		}
+	      list = list->next;
+	      if (attribute == att_exported)
+		array_needs_making++;
+	      continue;
+	    }
+
+	  assign = assignment (name);
+
+          if (assign)
+	    name[assign] = '\0';
+	  if (legal_identifier (name) == 0)
+	    {
+	      builtin_error ("%s: not a legal variable name", name);
+	      any_failed++;
+	      list = list->next;
+	      continue;
+	    }
+
+	  if (assign)
+	    {
+	      name[assign] = '=';
+	      /* This word has already been expanded once with command
+		 and parameter expansion.  Call do_assignment_no_expand (),
+		 which does not do command or parameter substitution. */
+	      do_assignment_no_expand (name);
+	      name[assign] = '\0';
+	    }
+
+	  if (undo)
+	    {
+	      var = find_variable (name);
+	      if (var)
+		var->attributes &= ~attribute;
+	    }
+	  else
+	    {
+	      SHELL_VAR *find_tempenv_variable (), *tv;
+
+	      if (tv = find_tempenv_variable (name))
+		{
+		  var = bind_variable (tv->name, tv->value);
+		  dispose_variable (tv);
+		}
+	      else
+		var = find_variable (name);
+
+	      if (!var)
+		{
+		  var = bind_variable (name, (char *)NULL);
+		  var->attributes |= att_invisible;
+		}
+
+	      var->attributes |= attribute;
+	    }
+
+	  array_needs_making++;	/* XXX */
+	  list = list->next;
+	}
+    }
+  else
+    {
+      SHELL_VAR **variable_list;
+      register int i;
+
+      if ((attribute & att_function) || functions_only)
+	{
+	  variable_list = all_shell_functions ();
+	  if (attribute != att_function)
+	    attribute &= ~att_function;	/* so declare -xf works, for example */
+	}
+      else
+	variable_list = all_shell_variables ();
+
+      if (variable_list)
+	{
+	  for (i = 0; var = variable_list[i]; i++)
+	    {
+	      if ((var->attributes & attribute) && !invisible_p (var))
+		{
+		  char flags[6];
+
+		  flags[0] = '\0';
+
+		  if (exported_p (var))
+		    strcat (flags, "x");
+
+		  if (readonly_p (var))
+		    strcat (flags, "r");
+
+		  if (function_p (var))
+		    strcat (flags, "f");
+
+		  if (integer_p (var))
+		    strcat (flags, "i");
+
+		  if (flags[0])
+		    {
+		      printf ("declare -%s ", flags);
+
+		      if (!function_p (var))
+			{
+			  char *x = double_quote (value_cell (var));
+			  printf ("%s=%s\n", var->name, x);
+			  free (x);
+			}
+		      else
+			{
+			  char *named_function_string ();
+
+			  printf ("%s\n", named_function_string
+				  (var->name, function_cell (var), 1));
+			}
+		    }
+		}
+	    }
+	  free (variable_list);
+	}
+    }
+  return (any_failed == 0 ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
+}

builtins/shift.def

@@ -0,0 +1,95 @@
+This file is shift.def, from which is created shift.c.
+It implements the builtin "shift" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES shift.c
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+
+$BUILTIN shift
+$FUNCTION shift_builtin
+$SHORT_DOC shift [n]
+The positional parameters from $N+1 ... are renamed to $1 ...  If N is
+not given, it is assumed to be 1.
+$END
+
+/* Shift the arguments ``left''.  Shift DOLLAR_VARS down then take one
+   off of REST_OF_ARGS and place it into DOLLAR_VARS[9].  If LIST has
+   anything in it, it is a number which says where to start the
+   shifting.  Return > 0 if `times' > $#, otherwise 0. */
+int
+shift_builtin (list)
+     WORD_LIST *list;
+{
+  int times, number;
+  WORD_LIST *args;
+
+  times = get_numeric_arg (list);
+
+  if (!times)
+    return (EXECUTION_SUCCESS);
+
+  if (times < 0)
+    {
+      builtin_error ("shift count must be >= 0");
+      return (EXECUTION_FAILURE);
+    }
+
+  args = list_rest_of_args ();
+  number = list_length (args);
+  dispose_words (args);
+
+  if (times > number)
+    {
+      builtin_error ("shift count must be <= $#");
+      return (EXECUTION_FAILURE);
+    }
+
+  while (times-- > 0)
+    {
+      register int count;
+
+      if (dollar_vars[1])
+	free (dollar_vars[1]);
+
+      for (count = 1; count < 9; count++)
+	dollar_vars[count] = dollar_vars[count + 1];
+
+      if (rest_of_args)
+	{
+	  WORD_LIST *temp = rest_of_args;
+
+	  dollar_vars[9] = savestring (temp->word->word);
+	  rest_of_args = rest_of_args->next;
+	  temp->next = (WORD_LIST *)NULL;
+	  dispose_words (temp);
+	}
+      else
+	dollar_vars[9] = (char *)NULL;
+    }
+
+  return (EXECUTION_SUCCESS);
+}

builtins/source.def

@@ -0,0 +1,186 @@
+This file is source.def, from which is created source.c.
+It implements the builtins "." and  "source" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES source.c
+
+$BUILTIN source
+$FUNCTION source_builtin
+$SHORT_DOC source filename
+Read and execute commands from FILENAME and return.  The pathnames
+in $PATH are used to find the directory containing FILENAME.
+$END
+$BUILTIN .
+$DOCNAME dot
+$FUNCTION source_builtin
+$SHORT_DOC . filename
+Read and execute commands from FILENAME and return.  The pathnames
+in $PATH are used to find the directory containing FILENAME.
+$END
+/* source.c - Implements the `.' and `source' builtins. */
+
+#include <sys/types.h>
+#include <sys/file.h>
+#include <errno.h>
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+#include "../posixstat.h"
+#include "../filecntl.h"
+#include "../execute_cmd.h"
+
+/* Not all systems declare ERRNO in errno.h... and some systems #define it! */
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+
+/* Variables used here but defined in other files. */
+extern int return_catch_flag, return_catch_value;
+extern jmp_buf return_catch;
+extern int posixly_correct;
+extern int interactive, interactive_shell, last_command_exit_value;
+
+/* How many `levels' of sourced files we have. */
+int sourcelevel = 0;
+
+/* If this . script is supplied arguments, we save the dollar vars and
+   replace them with the script arguments for the duration of the script's
+   execution.  If the script does not change the dollar vars, we restore
+   what we saved.  If the dollar vars are changed in the script, we leave
+   the new values alone and free the saved values. */
+static void
+maybe_pop_dollar_vars ()
+{
+  if (dollar_vars_changed ())
+    {
+      dispose_saved_dollar_vars ();
+      set_dollar_vars_unchanged ();
+    }
+  else
+    pop_dollar_vars ();
+}
+
+/* Read and execute commands from the file passed as argument.  Guess what.
+   This cannot be done in a subshell, since things like variable assignments
+   take place in there.  So, I open the file, place it into a large string,
+   close the file, and then execute the string. */
+source_builtin (list)
+     WORD_LIST *list;
+{
+  int result, return_val;
+
+  /* Assume the best. */
+  result = EXECUTION_SUCCESS;
+
+  if (list)
+    {
+      char *string, *filename;
+      struct stat finfo;
+      int fd, tt;
+
+      filename = find_path_file (list->word->word);
+      if (!filename)
+	filename = savestring (list->word->word);
+
+      if (((fd = open (filename, O_RDONLY)) < 0) || (fstat (fd, &finfo) < 0))
+	goto file_error_exit;
+
+      string = (char *)xmalloc (1 + (int)finfo.st_size);
+      tt = read (fd, string, finfo.st_size);
+      string[finfo.st_size] = '\0';
+
+      /* Close the open file, preserving the state of errno. */
+      { int temp = errno; close (fd); errno = temp; }
+
+      if (tt != finfo.st_size)
+	{
+	  free (string);
+
+	file_error_exit:
+	  file_error (filename);
+	  free (filename);
+
+	  /* POSIX shells exit if non-interactive and file error. */
+	  if (posixly_correct && !interactive_shell)
+	    {
+	      last_command_exit_value = 1;
+	      longjmp (top_level, EXITPROG);
+	    }
+
+	  return (EXECUTION_FAILURE);
+	}
+
+      if (tt > 80)
+	tt = 80;
+
+      if (check_binary_file ((unsigned char *)string, tt))
+	{
+	  free (string);
+	  builtin_error ("%s: cannot execute binary file", filename);
+	  free (filename);
+	  return (EX_BINARY_FILE);
+	}
+
+      begin_unwind_frame ("File Sourcing");
+
+      if (list->next)
+	{
+	  push_dollar_vars ();
+	  add_unwind_protect ((Function *)maybe_pop_dollar_vars, (char *)NULL);
+	  remember_args (list->next, 1);
+	}
+
+      unwind_protect_int (return_catch_flag);
+      unwind_protect_jmp_buf (return_catch);
+      unwind_protect_int (interactive);
+      unwind_protect_int (sourcelevel);
+      add_unwind_protect ((Function *)xfree, filename);
+      interactive = 0;
+      sourcelevel++;
+
+      set_dollar_vars_unchanged ();
+
+      return_catch_flag++;
+      return_val = setjmp (return_catch);
+
+      if (return_val)
+	parse_and_execute_cleanup ();
+      else
+	result = parse_and_execute (string, filename, -1);
+
+      run_unwind_frame ("File Sourcing");
+
+      /* If RETURN_VAL is non-zero, then we return the value given
+	 to return_builtin (), since that is how we got here. */
+      if (return_val)
+	result = return_catch_value;
+    }
+  else
+    {
+      builtin_error ("filename argument required");
+      result = EXECUTION_FAILURE;
+    }
+  return (result);
+}

builtins/suspend.def

@@ -0,0 +1,86 @@
+This file is suspend.def, from which is created suspend.c.
+It implements the builtin "suspend" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES suspend.c
+
+$BUILTIN suspend
+$DEPENDS_ON JOB_CONTROL
+$FUNCTION suspend_builtin
+$SHORT_DOC suspend [-f]
+Suspend the execution of this shell until it receives a SIGCONT
+signal.  The `-f' if specified says not to complain about this
+being a login shell if it is; just suspend anyway.
+$END
+
+#include <sys/types.h>
+#include <signal.h>
+#include "../shell.h"
+#include "../jobs.h"
+
+#if defined (JOB_CONTROL)
+extern int job_control;
+
+static SigHandler *old_cont, *old_tstp;
+
+/* Continue handler. */
+sighandler
+suspend_continue (sig)
+     int sig;
+{
+  set_signal_handler (SIGCONT, old_cont);
+  set_signal_handler (SIGTSTP, old_tstp);
+#if !defined (VOID_SIGHANDLER)
+  return (0);
+#endif /* !VOID_SIGHANDLER */
+}
+
+/* Suspending the shell.  If -f is the arg, then do the suspend
+   no matter what.  Otherwise, complain if a login shell. */
+int
+suspend_builtin (list)
+     WORD_LIST *list;
+{
+  if (!job_control)
+    {
+      builtin_error ("Cannot suspend a shell without job control");
+      return (EXECUTION_FAILURE);
+    }
+
+  if (list)
+    if (strcmp (list->word->word, "-f") == 0)
+      goto do_suspend;
+
+  no_args (list);
+
+  if (login_shell)
+    {
+      builtin_error ("Can't suspend a login shell");
+      return (EXECUTION_FAILURE);
+    }
+
+do_suspend:
+  old_cont = (SigHandler *)set_signal_handler (SIGCONT, suspend_continue);
+  old_tstp = (SigHandler *)set_signal_handler (SIGTSTP, SIG_DFL);
+  killpg (shell_pgrp, SIGTSTP);
+  return (EXECUTION_SUCCESS);
+}
+
+#endif /* JOB_CONTROL */

builtins/test.def

@@ -0,0 +1,144 @@
+This file is test.def, from which is created test.c.
+It implements the builtin "test" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES test.c
+
+$BUILTIN test
+$FUNCTION test_builtin
+$SHORT_DOC test [expr]
+Exits with a status of 0 (trueness) or 1 (falseness) depending on
+the evaluation of EXPR.  Expressions may be unary or binary.  Unary
+expressions are often used to examine the status of a file.  There
+are string operators as well, and numeric comparison operators.
+
+File operators:
+
+    -b FILE        True if file is block special.
+    -c FILE        True if file is character special.
+    -d FILE        True if file is a directory.
+    -e FILE        True if file exists.
+    -f FILE        True if file exists and is a regular file.
+    -g FILE        True if file is set-group-id.
+    -h FILE        True if file is a symbolic link.  Use "-L".
+    -L FILE        True if file is a symbolic link.
+    -k FILE        True if file has its "sticky" bit set.
+    -p FILE        True if file is a named pipe.
+    -r FILE        True if file is readable by you.
+    -s FILE        True if file is not empty.
+    -S FILE        True if file is a socket.
+    -t FD          True if FD is opened on a terminal.
+    -u FILE        True if the file is set-user-id.
+    -w FILE        True if the file is writable by you.
+    -x FILE        True if the file is executable by you.
+    -O FILE        True if the file is effectively owned by you.
+    -G FILE        True if the file is effectively owned by your group.
+
+  FILE1 -nt FILE2  True if file1 is newer than (according to
+                   modification date) file2.
+
+  FILE1 -ot FILE2  True if file1 is older than file2.
+
+  FILE1 -ef FILE2  True if file1 is a hard link to file2.
+
+String operators:
+
+    -z STRING      True if string is empty.
+
+    -n STRING
+ or STRING         True if string is not empty.
+
+    STRING1 = STRING2
+                   True if the strings are equal.
+    STRING1 != STRING2
+                   True if the strings are not equal.
+
+Other operators:
+
+    ! EXPR         True if expr is false.
+    EXPR1 -a EXPR2 True if both expr1 AND expr2 are true.
+    EXPR1 -o EXPR2 True if either expr1 OR expr2 is true.
+
+    arg1 OP arg2   Arithmetic tests.  OP is one of -eq, -ne,
+                   -lt, -le, -gt, or -ge.
+
+Arithmetic binary operators return true if ARG1 is equal, not-equal,
+less-than, less-than-or-equal, greater-than, or greater-than-or-equal
+than ARG2.
+$END
+
+$BUILTIN [
+$DOCNAME test_bracket
+$FUNCTION test_builtin
+$SHORT_DOC [ arg... ]
+This is a synonym for the "test" shell builtin, excepting that the
+last argument must be literally `]', to match the `[' which invoked
+the test.
+$END
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "../shell.h"
+extern char *this_command_name;
+
+/* TEST/[ builtin. */
+int
+test_builtin (list)
+     WORD_LIST *list;
+{
+  char **argv;
+  int argc, result;
+  WORD_LIST *t = list;
+
+  /* We let Matthew Bradburn and Kevin Braunsdorf's code do the
+     actual test command.  So turn the list of args into an array
+     of strings, since that is what his code wants. */
+  if (!list)
+    {
+      if (this_command_name[0] == '[' && !this_command_name[1])
+	builtin_error ("missing `]'");
+
+      return (EXECUTION_FAILURE);
+    }
+
+  /* Get the length of the argument list. */
+  for (argc = 0; t; t = t->next, argc++);
+
+  /* Account for argv[0] being a command name.  This makes our life easier. */
+  argc++;
+  argv = (char **)xmalloc ((1 + argc) * sizeof (char *));
+  argv[argc] = (char *)NULL;
+
+  /* this_command_name is the name of the command that invoked this
+     function.  So you can't call test_builtin () directly from
+     within this code, there are too many things to worry about. */
+  argv[0] = savestring (this_command_name);
+
+  for (t = list, argc = 1; t; t = t->next, argc++)
+    argv[argc] = savestring (t->word->word);
+
+  result = test_command (argc, argv);
+  free_array (argv);
+  return (result);
+}

builtins/times.def

@@ -0,0 +1,89 @@
+This file is times.def, from which is created times.c.
+It implements the builtin "times" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES times.c
+
+$BUILTIN times
+$FUNCTION times_builtin
+$SHORT_DOC times
+Print the accumulated user and system times for processes run from
+the shell.
+$END
+
+#include "../shell.h"
+#include <sys/types.h>
+
+#if defined (hpux) || defined (USGr4) || defined (XD88) || defined (USGr3)
+#  undef HAVE_RESOURCE
+#endif /* hpux || USGr4 || XD88 || USGr3 */
+
+#if defined (_POSIX_VERSION) || !defined (HAVE_RESOURCE)
+#  include <sys/times.h>
+#else /* !_POSIX_VERSION && HAVE_RESOURCE */
+#  include <sys/time.h>
+#  include <sys/resource.h>
+#endif /* !_POSIX_VERSION && HAVE_RESOURCE */
+
+/* Print the totals for system and user time used.  The
+   information comes from variables in jobs.c used to keep
+   track of this stuff. */
+times_builtin (list)
+     WORD_LIST *list;
+{
+#if !defined (_POSIX_VERSION) && defined (HAVE_RESOURCE) && defined (RUSAGE_SELF)
+  struct rusage self, kids;
+
+  getrusage (RUSAGE_SELF, &self);
+  getrusage (RUSAGE_CHILDREN, &kids);	/* terminated child processes */
+
+  print_timeval (&self.ru_utime);
+  putchar (' ');
+  print_timeval (&self.ru_stime);
+  putchar ('\n');
+  print_timeval (&kids.ru_utime);
+  putchar (' ');
+  print_timeval (&kids.ru_stime);
+  putchar ('\n');
+
+#else /* _POSIX_VERSION || !HAVE_RESOURCE || !RUSAGE_SELF */
+#  if !defined (BrainDeath)
+  struct tms t;
+
+  times (&t);
+
+  /* As of System V.3, HP-UX 6.5, and other ATT-like systems, this stuff is
+     returned in terms of clock ticks (HZ from sys/param.h).  C'mon, guys.
+     This kind of stupid clock-dependent stuff is exactly the reason 4.2BSD
+     introduced the `timeval' struct. */
+
+  print_time_in_hz (t.tms_utime);
+  putchar (' ');
+  print_time_in_hz (t.tms_stime);
+  putchar ('\n');
+  print_time_in_hz (t.tms_cutime);
+  putchar (' ');
+  print_time_in_hz (t.tms_cstime);
+  putchar ('\n');
+#  endif /* BrainDeath */
+#endif /* _POSIX_VERSION || !HAVE_RESOURCE || !RUSAGE_SELF */
+
+  return (EXECUTION_SUCCESS);
+}

builtins/trap.def

@@ -0,0 +1,204 @@
+This file is trap.def, from which is created trap.c.
+It implements the builtin "trap" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES trap.c
+
+$BUILTIN trap
+$FUNCTION trap_builtin
+$SHORT_DOC trap [arg] [signal_spec]
+The command ARG is to be read and executed when the shell receives
+signal(s) SIGNAL_SPEC.  If ARG is absent all specified signals are
+reset to their original values.  If ARG is the null string this
+signal is ignored by the shell and by the commands it invokes.  If
+SIGNAL_SPEC is EXIT (0) the command ARG is executed on exit from
+the shell.  The trap command with no arguments prints the list of
+commands associated with each signal number.  SIGNAL_SPEC is either
+a signal name in <signal.h>, or a signal number.  The syntax `trap -l'
+prints a list of signal names and their corresponding numbers.
+Note that a signal can be sent to the shell with "kill -signal $$".
+$END
+
+#include <sys/types.h>
+#include <signal.h>
+#include "../shell.h"
+#include "../trap.h"
+#include "common.h"
+
+/* The trap command:
+
+   trap <arg> <signal ...>
+   trap <signal ...>
+   trap -l
+   trap [--]
+
+   Set things up so that ARG is executed when SIGNAL(s) N is recieved.
+   If ARG is the empty string, then ignore the SIGNAL(s).  If there is
+   no ARG, then set the trap for SIGNAL(s) to its original value.  Just
+   plain "trap" means to print out the list of commands associated with
+   each signal number.  Single arg of "-l" means list the signal names. */
+
+/* Possible operations to perform on the list of signals.*/
+#define SET 0			/* Set this signal to first_arg. */
+#define REVERT 1		/* Revert to this signals original value. */
+#define IGNORE 2		/* Ignore this signal. */
+
+extern int interactive;
+
+trap_builtin (list)
+     WORD_LIST *list;
+{
+  register int i;
+  int list_signal_names = 0;
+
+  while (list)
+    {
+      if (ISOPTION (list->word->word, 'l'))
+	{
+	  list_signal_names++;
+	  list = list->next;
+	}
+      else if (ISOPTION (list->word->word, '-'))
+	{
+	  list = list->next;
+	  break;
+	}
+      else if ((*list->word->word == '-') && list->word->word[1])
+	{
+	  bad_option (list->word->word);
+	  builtin_error ("usage: trap [-l] [arg] [sigspec]");
+	  return (EX_USAGE);
+	}
+      else
+	break;
+    }
+
+  if (list_signal_names)
+    {
+      int column = 0;
+
+      for (i = 0; i < NSIG; i++)
+	{
+	  printf ("%2d) %s", i, signal_name (i));
+	  if (++column < 4)
+	    printf ("\t");
+	  else
+	    {
+	      printf ("\n");
+	      column = 0;
+	    }
+	}
+      if (column != 0)
+	printf ("\n");
+      return (EXECUTION_SUCCESS);
+    }
+
+  if (list)
+    {
+      char *first_arg = list->word->word;
+      int operation = SET, any_failed = 0;
+
+      if (signal_object_p (first_arg))
+	operation = REVERT;
+      else
+	{
+	  list = list->next;
+	  if (*first_arg == '\0')
+	    operation = IGNORE;
+	  else if (first_arg[0] == '-' && !first_arg[1])
+	    operation = REVERT;
+	}
+
+      while (list)
+	{
+	  int sig;
+
+	  sig = decode_signal (list->word->word);
+
+	  if (sig == NO_SIG)
+	    {
+	      builtin_error ("%s: not a signal specification",
+			     list->word->word);
+	      any_failed++;
+	    }
+	  else
+	    {
+	      switch (operation)
+		{
+		  case SET:
+		    set_signal (sig, first_arg);
+		    break;
+
+		  case REVERT:
+		    restore_default_signal (sig);
+
+		    /* Signals that the shell treats specially need special
+		       handling. */
+		    switch (sig)
+		      {
+		      case SIGINT:
+			if (interactive)
+			  set_signal_handler (SIGINT, sigint_sighandler);
+			else
+			  set_signal_handler (SIGINT, termination_unwind_protect);
+			break;
+
+		      case SIGQUIT:
+			/* Always ignore SIGQUIT. */
+			set_signal_handler (SIGQUIT, SIG_IGN);
+			break;
+		      case SIGTERM:
+#if defined (JOB_CONTROL)
+		      case SIGTTIN:
+		      case SIGTTOU:
+		      case SIGTSTP:
+#endif /* JOB_CONTROL */
+			if (interactive)
+			  set_signal_handler (sig, SIG_IGN);
+			break;
+		      }
+		    break;
+
+		  case IGNORE:
+		    ignore_signal (sig);
+		    break;
+		}
+	    }
+	  list = list->next;
+	}
+      return ((!any_failed) ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
+    }
+
+  for (i = 0; i < NSIG; i++)
+    {
+      char *t, *p;
+
+      p = trap_list[i];
+
+      if (p == (char *)DEFAULT_SIG)
+	continue;
+
+      t = (p == (char *)IGNORE_SIG) ? (char *)NULL : single_quote (p);
+      printf ("trap -- %s %s\n", t ? t : "''", signal_name (i));
+      if (t)
+	free (t);
+    }
+  return (EXECUTION_SUCCESS);
+}

builtins/type.def

@@ -0,0 +1,325 @@
+This file is type.def, from which is created type.c.
+It implements the builtin "type" in Bash.
+
+Copyright (C) 1987, 1989, 1991, 1992 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES type.c
+
+$BUILTIN type
+$FUNCTION type_builtin
+$SHORT_DOC type [-all] [-type | -path] [name ...]
+For each NAME, indicate how it would be interpreted if used as a
+command name.
+
+If the -type flag is used, returns a single word which is one of
+`alias', `keyword', `function', `builtin', `file' or `', if NAME is an
+alias, shell reserved word, shell function, shell builtin, disk file,
+or unfound, respectively.
+
+If the -path flag is used, either returns the name of the disk file
+that would be exec'ed, or nothing if -type wouldn't return `file'.
+
+If the -all flag is used, displays all of the places that contain an
+executable named `file'.  This includes aliases and functions, if and
+only if the -path flag is not also used.
+$END
+
+#include <stdio.h>
+#include <sys/types.h>
+#include "../posixstat.h"
+#include "../shell.h"
+#include "../execute_cmd.h"
+
+#if defined (ALIAS)
+#include "../alias.h"
+#endif /* ALIAS */
+
+#include "common.h"
+
+extern STRING_INT_ALIST word_token_alist[];
+
+/* For each word in LIST, find out what the shell is going to do with
+   it as a simple command. i.e., which file would this shell use to
+   execve, or if it is a builtin command, or an alias.  Possible flag
+   arguments:
+	-type		Returns the "type" of the object, one of
+			`alias', `keyword', `function', `builtin',
+			or `file'.
+
+	-path		Returns the pathname of the file if -type is
+			a file.
+
+	-all		Returns all occurrences of words, whether they
+			be a filename in the path, alias, function,
+			or builtin.
+   Order of evaluation:
+	alias
+	keyword
+	function
+	builtin
+	file
+ */
+type_builtin (list)
+     WORD_LIST *list;
+{
+  int path_only, type_only, all, verbose;
+  int successful_finds;
+
+  path_only = type_only = all = 0;
+  successful_finds = 0;
+
+  if (!list)
+    return (EXECUTION_SUCCESS);
+
+  while (list && *(list->word->word) == '-')
+    {
+      char *flag = &(list->word->word[1]);
+
+      if (flag[0] == 't' && (!flag[1] || strcmp (flag + 1, "ype") == 0))
+	{
+	  type_only = 1;
+	  path_only = 0;
+	}
+      else if (flag[0] == 'p' && (!flag[1] || strcmp (flag + 1, "ath") == 0))
+	{
+	  path_only = 1;
+	  type_only = 0;
+	}
+      else if (flag[0] == 'a' && (!flag[1] || strcmp (flag + 1, "ll") == 0))
+	{
+	  all = 1;
+	}
+      else
+	{
+	  bad_option (flag);
+	  builtin_error ("usage: type [-all | -path | -type ] name [name ...]");
+	  return (EX_USAGE);
+	}
+      list = list->next;
+    }
+
+  if (type_only)
+    verbose = 1;
+  else if (!path_only)
+    verbose = 2;
+  else if (path_only)
+    verbose = 3;
+  else
+    verbose = 0;
+
+  while (list)
+    {
+      int found;
+
+      found = describe_command (list->word->word, verbose, all);
+
+      if (!found && !path_only && !type_only)
+	builtin_error ("%s: not found", list->word->word);
+
+      successful_finds += found;
+      list = list->next;
+    }
+
+  fflush (stdout);
+
+  if (successful_finds != 0)
+    return (EXECUTION_SUCCESS);
+  else
+    return (EXECUTION_FAILURE);
+}
+
+/*
+ * Describe COMMAND as required by the type builtin.
+ *
+ * If VERBOSE == 0, don't print anything
+ * If VERBOSE == 1, print short description as for `type -t'
+ * If VERBOSE == 2, print long description as for `type' and `command -V'
+ * If VERBOSE == 3, print path name only for disk files
+ * If VERBOSE == 4, print string used to invoke COMMAND, for `command -v'
+ *
+ * ALL says whether or not to look for all occurrences of COMMAND, or
+ * return after finding it once.
+ */
+describe_command (command, verbose, all)
+     char *command;
+     int verbose, all;
+{
+  int found = 0, i, found_file = 0;
+  char *full_path = (char *)NULL;
+  SHELL_VAR *func;
+
+#if defined (ALIAS)
+  /* Command is an alias? */
+  ASSOC *alias = find_alias (command);
+
+  if (alias)
+    {
+      if (verbose == 1)
+	printf ("alias\n");
+      else if (verbose == 2)
+	printf ("%s is aliased to `%s'\n", command, alias->value);
+      else if (verbose == 4)
+	{
+	  char *x = single_quote (alias->value);
+	  printf ("alias %s=%s\n", command, x);
+	  free (x);
+	}
+
+      found = 1;
+
+      if (!all)
+	return (1);
+    }
+#endif /* ALIAS */
+
+  /* Command is a shell reserved word? */
+  i = find_reserved_word (command);
+  if (i >= 0)
+    {
+      if (verbose == 1)
+	printf ("keyword\n");
+      else if (verbose == 2)
+	printf ("%s is a shell keyword\n", command);
+      else if (verbose == 4)
+	printf ("%s\n", command);
+
+      found = 1;
+
+      if (!all)
+	return (1);
+    }
+
+  /* Command is a function? */
+  func = find_function (command);
+
+  if (func)
+    {
+      if (verbose == 1)
+	printf ("function\n");
+      else if (verbose == 2)
+	{
+#define PRETTY_PRINT_FUNC 1
+	  char *result;
+
+	  printf ("%s is a function\n", command);
+
+	  /* We're blowing away THE_PRINTED_COMMAND here... */
+
+	  result = named_function_string (command,
+					  (COMMAND *) function_cell (func),
+					  PRETTY_PRINT_FUNC);
+	  printf ("%s\n", result);
+#undef PRETTY_PRINT_FUNC
+	}
+      else if (verbose == 4)
+	printf ("%s\n", command);
+
+      found = 1;
+
+      if (!all)
+	return (1);
+    }
+
+  /* Command is a builtin? */
+  if (find_shell_builtin (command))
+    {
+      if (verbose == 1)
+	printf ("builtin\n");
+      else if (verbose == 2)
+	printf ("%s is a shell builtin\n", command);
+      else if (verbose == 4)
+	printf ("%s\n", command);
+
+      found = 1;
+
+      if (!all)
+	return (1);
+    }
+
+  /* Command is a disk file? */
+  /* If the command name given is already an absolute command, just
+     check to see if it is executable. */
+  if (absolute_program (command))
+    {
+      int f = file_status (command);
+      if (f & FS_EXECABLE)
+        {
+	  if (verbose == 1)
+	    printf ("file\n");
+	  else if (verbose == 2)
+	    printf ("%s is %s\n", command, command);
+	  else if (verbose == 3 || verbose == 4)
+	    printf ("%s\n", command);
+
+	  /* There's no use looking in the hash table or in $PATH,
+	     because they're not consulted when an absolute program
+	     name is supplied. */
+	  return (1);
+        }
+    }
+
+  /* If the user isn't doing "-all", then we might care about
+     whether the file is present in our hash table. */
+  if (!all)
+    {
+      if ((full_path = find_hashed_filename (command)) != (char *)NULL)
+	{
+	  if (verbose == 1)
+	    printf ("file\n");
+	  else if (verbose == 2)
+	    printf ("%s is hashed (%s)\n", command, full_path);
+	  else if (verbose == 3 || verbose == 4)
+	    printf ("%s\n", full_path);
+
+	  return (1);
+	}
+    }
+
+  /* Now search through $PATH. */
+  while (1)
+    {
+      if (!all)
+	full_path = find_user_command (command);
+      else
+	full_path =
+	  user_command_matches (command, FS_EXEC_ONLY, found_file);
+	  /* XXX - should that be FS_EXEC_PREFERRED? */
+
+      if (!full_path)
+	break;
+
+      found_file++;
+      found = 1;
+
+      if (verbose == 1)
+	printf ("file\n");
+      else if (verbose == 2)
+	printf ("%s is %s\n", command, full_path);
+      else if (verbose == 3 || verbose == 4)
+	printf ("%s\n", full_path);
+
+      free (full_path);
+      full_path = (char *)NULL;
+
+      if (!all)
+	break;
+    }
+
+  return (found);
+}

builtins/ulimit.def

@@ -0,0 +1,731 @@
+This file is ulimit.def, from which is created ulimit.c.
+It implements the builtin "ulimit" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES ulimit.c
+
+$BUILTIN ulimit
+$FUNCTION ulimit_builtin
+$DEPENDS_ON !MINIX
+$SHORT_DOC ulimit [-SHacdfmstpnuv [limit]]
+Ulimit provides control over the resources available to processes
+started by the shell, on systems that allow such control.  If an
+option is given, it is interpreted as follows:
+
+    -S	use the `soft' resource limit
+    -H	use the `hard' resource limit
+    -a	all current limits are reported
+    -c	the maximum size of core files created
+    -d	the maximum size of a process's data segment
+    -m	the maximum resident set size
+    -s	the maximum stack size
+    -t	the maximum amount of cpu time in seconds
+    -f	the maximum size of files created by the shell
+    -p	the pipe buffer size
+    -n	the maximum number of open file descriptors
+    -u	the maximum number of user processes
+    -v	the size of virtual memory 
+
+If LIMIT is given, it is the new value of the specified resource.
+Otherwise, the current value of the specified resource is printed.
+If no option is given, then -f is assumed.  Values are in 1k
+increments, except for -t, which is in seconds, -p, which is in
+increments of 512 bytes, and -u, which is an unscaled number of
+processes.
+$END
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <errno.h>
+#include "../shell.h"
+#include "pipesize.h"
+
+#if !defined (errno)
+extern int errno;
+#endif
+
+#if defined (HAVE_RESOURCE)
+#  include <sys/time.h>
+#  include <sys/resource.h>
+#else
+#  include <sys/times.h>
+#endif
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>
+#endif
+
+#if defined (HAVE_LIMITS_H)
+#  include <limits.h>
+#endif
+
+/* Check for the most basic symbols.  If they aren't present, this
+   system's <sys/resource.h> isn't very useful to us. */
+#if !defined (RLIMIT_FSIZE) || defined (GETRLIMIT_MISSING)
+#  undef HAVE_RESOURCE
+#endif
+
+#if !defined (RLIMTYPE)
+#  define RLIMTYPE long
+#  define string_to_rlimtype string_to_long
+#  define print_rlimtype(num, nl) printf ("%ld%s", num, nl ? "\n" : "")
+#endif
+
+static void print_long ();
+
+/* **************************************************************** */
+/*								    */
+/*			Ulimit builtin and Hacks.       	    */
+/*								    */
+/* **************************************************************** */
+
+/* Block size for ulimit operations. */
+#define ULIMIT_BLOCK_SIZE ((long)1024)
+
+#define u_FILE_SIZE 		0x001
+#define u_MAX_BREAK_VAL		0x002
+#define u_PIPE_SIZE		0x004
+#define u_CORE_FILE_SIZE	0x008
+#define u_DATA_SEG_SIZE		0x010
+#define u_PHYS_MEM_SIZE		0x020
+#define u_CPU_TIME_LIMIT	0x040
+#define u_STACK_SIZE		0x080
+#define u_NUM_OPEN_FILES	0x100
+#define u_MAX_VIRTUAL_MEM	0x200
+#define u_MAX_USER_PROCS	0x400
+
+#define u_ALL_LIMITS		0x7ff
+
+#if !defined (RLIM_INFINITY)
+#  define RLIM_INFINITY  0x7fffffff
+#endif
+
+/* Some systems use RLIMIT_NOFILE, others use RLIMIT_OFILE */
+#if defined (HAVE_RESOURCE) && defined (RLIMIT_OFILE) && !defined (RLIMIT_NOFILE)
+#  define RLIMIT_NOFILE RLIMIT_OFILE
+#endif /* HAVE_RESOURCE && RLIMIT_OFILE && !RLIMIT_NOFILE */
+
+#define LIMIT_HARD 0x01
+#define LIMIT_SOFT 0x02
+
+static RLIMTYPE shell_ulimit ();
+static RLIMTYPE pipesize ();
+static RLIMTYPE open_files ();
+
+#if defined (HAVE_RESOURCE)
+static RLIMTYPE getmaxvm ();
+#endif /* HAVE_RESOURCE */
+
+static void print_specific_limits ();
+static void print_all_limits ();
+
+static char t[2];
+
+/* Return 1 if the limit associated with CMD can be raised from CURRENT
+   to NEW.  This is for USG systems without HAVE_RESOURCE, most of which
+   do not allow any user other than root to raise limits.  There are,
+   however, exceptions. */
+#if !defined (HAVE_RESOURCE)
+static int
+canraise (cmd, current, new)
+     int cmd;
+     RLIMTYPE current, new;
+{
+#  if defined (HAVE_SETDTABLESIZE)
+  if (cmd == u_NUM_OPEN_FILES)
+    return (1);
+#  endif /* HAVE_SETDTABLSIZE */
+
+  return ((current > new) || (current_user.uid == 0));
+}
+#endif /* !HAVE_RESOURCE */
+
+/* Report or set limits associated with certain per-process resources.
+   See the help documentation in builtins.c for a full description.
+
+   Rewritten by Chet Ramey 6/30/91. */
+int
+ulimit_builtin (list)
+     register WORD_LIST *list;
+{
+  register char *s;
+  int c, setting, cmd, mode, verbose_print, opt_eof;
+  int all_limits, specific_limits;
+  long block_factor;
+  RLIMTYPE current_limit, real_limit, limit;
+
+  c = mode = verbose_print = opt_eof = 0;
+  limit = (RLIMTYPE)-1;
+
+  do
+    {
+      cmd = setting = all_limits = specific_limits = 0;
+      block_factor = ULIMIT_BLOCK_SIZE;
+
+      /* read_options: */
+      if (list && !opt_eof && *list->word->word == '-')
+	{
+	  s = &(list->word->word[1]);
+	  list = list->next;
+
+	  while (*s && (c = *s++))
+	    {
+	      switch (c)
+		{
+#define ADD_CMD(x) { if (cmd) specific_limits++; cmd |= (x); }
+
+		case '-':	/* ulimit -- */
+		  opt_eof++;
+		  break;
+		  
+		case 'a':
+		  all_limits++;
+		  break;
+
+		case 'f':
+		  ADD_CMD (u_FILE_SIZE);
+		  break;
+
+#if defined (HAVE_RESOURCE)
+		/* -S and -H are modifiers, not real options.  */
+		case 'S':
+		  mode |= LIMIT_SOFT;
+		  break;
+
+		case 'H':
+		  mode |= LIMIT_HARD;
+		  break;
+
+		case 'c':
+		  ADD_CMD (u_CORE_FILE_SIZE);
+		  break;
+
+		case 'd':
+		  ADD_CMD (u_DATA_SEG_SIZE);
+		  break;
+
+#if !defined (USGr4)
+		case 'm':
+		  ADD_CMD (u_PHYS_MEM_SIZE);
+		  break;
+#endif /* USGr4 */
+
+		case 't':
+		  ADD_CMD (u_CPU_TIME_LIMIT);
+		  block_factor = 1;	/* seconds */
+		  break;
+
+		case 's':
+		  ADD_CMD (u_STACK_SIZE);
+		  break;
+
+		case 'v':
+		  ADD_CMD (u_MAX_VIRTUAL_MEM);
+		  block_factor = 1;
+		  break;
+
+		case 'u':
+		  ADD_CMD (u_MAX_USER_PROCS);
+		  block_factor = 1;
+		  break;
+
+#endif /* HAVE_RESOURCE */
+
+		case 'p':
+		  ADD_CMD (u_PIPE_SIZE);
+		  block_factor = 512;
+		  break;
+
+		case 'n':
+		  ADD_CMD (u_NUM_OPEN_FILES);
+		  block_factor = 1;
+		  break;
+
+		default:		/* error_case: */
+		  t[0] = c;
+		  t[1] = '\0';
+		  bad_option (t);
+#if !defined (HAVE_RESOURCE)
+		  builtin_error("usage: ulimit [-afnp] [new limit]");
+#else
+		  builtin_error("usage: ulimit [-SHacmdstfnpuv] [new limit]");
+#endif
+		  return (EX_USAGE);
+		}
+	    }
+	}
+
+	if (all_limits)
+	  {
+	    print_all_limits (mode);
+	    return (EXECUTION_SUCCESS);
+	  }
+
+	if (specific_limits)
+	  {
+	    print_specific_limits (cmd, mode);
+	    if (list)
+	      verbose_print++;
+	    continue;
+	  }
+
+	if (cmd == 0)
+	  cmd = u_FILE_SIZE;
+
+ 	/* If an argument was supplied for the command, then we want to
+	   set the limit.  Note that `ulimit something' means a command
+	   of -f with argument `something'. */
+	if (list)
+	  {
+	    if (opt_eof || (*list->word->word != '-'))
+	      {
+		s = list->word->word;
+		list = list->next;
+
+		if (STREQ (s, "unlimited"))
+		  limit = RLIM_INFINITY;
+		else if (all_digits (s))
+		  limit = string_to_rlimtype (s);
+		else
+		  {
+		    builtin_error ("bad non-numeric arg `%s'", s);
+		    return (EXECUTION_FAILURE);
+		  }
+		setting++;
+	      }
+	    else if (!opt_eof)
+	      verbose_print++;
+	  }
+
+      if (limit == RLIM_INFINITY)
+	block_factor = 1;
+
+      real_limit = limit * block_factor;
+
+      /* If more than one option is given, list each in a verbose format,
+	 the same that is used for -a. */
+      if (!setting && verbose_print)
+	{
+	  print_specific_limits (cmd, mode);
+	  continue;
+	}
+
+      current_limit = shell_ulimit (cmd, real_limit, 0, mode);
+
+      if (setting)
+	{
+#if !defined (HAVE_RESOURCE)
+	  /* Most USG systems do not most allow limits to be raised by any
+	     user other than root.  There are, however, exceptions. */
+	  if (canraise (cmd, current_limit, real_limit) == 0)
+	    {
+	      builtin_error ("cannot raise limit: %s", strerror (EPERM));
+	      return (EXECUTION_FAILURE);
+	    }
+#endif /* !HAVE_RESOURCE */
+
+	  if (shell_ulimit (cmd, real_limit, 1, mode) == (RLIMTYPE)-1)
+	    {
+	      builtin_error ("cannot raise limit: %s", strerror (errno));
+	      return (EXECUTION_FAILURE);
+	    }
+
+	  continue;
+	}
+      else
+	{
+	  if (current_limit < 0)
+	    builtin_error ("cannot get limit: %s", strerror (errno));
+	  else if (current_limit != RLIM_INFINITY)
+	    print_rlimtype ((current_limit / block_factor), 1);
+	  else
+	    printf ("unlimited\n");
+	}
+    }
+  while (list);
+
+  return (EXECUTION_SUCCESS);
+}
+
+/* The ulimit that we call from within Bash.
+
+   WHICH says which limit to twiddle; SETTING is non-zero if NEWLIM
+   contains the desired new limit.  Otherwise, the existing limit is
+   returned.  If mode & LIMIT_HARD, the hard limit is used; if
+   mode & LIMIT_SOFT, the soft limit.  Both may be set by specifying
+   -H and -S; if both are specified, or if neither is specified, the
+   soft limit will be returned.
+
+   Systems without BSD resource limits can specify only u_FILE_SIZE.
+   This includes most USG systems.
+
+   Chet Ramey supplied the BSD resource limit code. */
+static RLIMTYPE
+shell_ulimit (which, newlim, setting, mode)
+     int which, setting, mode;
+     RLIMTYPE newlim;
+{
+#if defined (HAVE_RESOURCE)
+  struct rlimit limit;
+  int cmd;
+
+  if (mode == 0)
+    mode |= LIMIT_SOFT;
+#endif
+
+  switch (which)
+    {
+#if !defined (HAVE_RESOURCE)
+
+    case u_FILE_SIZE:
+      if (!setting)
+	{
+	  /* ulimit () returns a number that is in 512 byte blocks, thus we
+	     must multiply it by 512 to get back to bytes.  This is false
+	     only under HP/UX 6.x. */
+	  RLIMTYPE result;
+
+	  result = ulimit (1, 0L);
+
+#  if defined (hpux) && !defined (_POSIX_VERSION)
+	  return (result);
+#  else
+	  return (result * 512);
+#  endif /* hpux 6.x */
+	}
+      else
+	return (ulimit (2, newlim / 512L));
+
+      break;
+
+#else /* defined (HAVE_RESOURCE) */
+
+    case u_FILE_SIZE:
+      cmd = RLIMIT_FSIZE;
+      goto do_ulimit;
+
+    case u_CORE_FILE_SIZE:
+      cmd = RLIMIT_CORE;
+      goto do_ulimit;
+
+    case u_DATA_SEG_SIZE:
+      cmd = RLIMIT_DATA;
+      goto do_ulimit;
+
+#if !defined (USGr4)
+    case u_PHYS_MEM_SIZE:
+#  if defined (RLIMIT_RSS)
+      cmd = RLIMIT_RSS;
+#  else /* !RLIMIT_RSS */
+      errno = EINVAL;
+      return ((RLIMTYPE)-1);
+#  endif /* !RLIMIT_RSS */
+
+      goto do_ulimit;
+#endif /* USGr4 */
+
+    case u_CPU_TIME_LIMIT:
+#if defined (RLIMIT_CPU)
+      cmd = RLIMIT_CPU;
+      goto do_ulimit;
+#else
+      errno = EINVAL;
+      return ((RLIMTYPE)-1);
+#  endif /* !RLIMIT_CPU */
+
+
+    case u_STACK_SIZE:
+      cmd = RLIMIT_STACK;
+
+    do_ulimit:
+
+      if (getrlimit (cmd, &limit) != 0)
+	return ((RLIMTYPE)-1);
+
+      if (!setting)
+	{
+	  if (mode & LIMIT_SOFT)
+	    return (limit.rlim_cur);
+	  else
+	    return (limit.rlim_max);
+	}
+      else
+	{
+	  if (mode & LIMIT_SOFT)
+	    {
+	      /* Non-root users are only allowed to raise a limit up to the
+		 hard limit, not to infinity. */
+	      if (current_user.euid != 0 && newlim == RLIM_INFINITY)
+		limit.rlim_cur = limit.rlim_max;
+	      else
+		limit.rlim_cur = newlim;
+	    }
+	  if (mode & LIMIT_HARD)
+	    limit.rlim_max = newlim;
+
+	  return (setrlimit (cmd, &limit));
+	}
+
+      break;
+
+#endif /* HAVE_RESOURCE */
+
+      /* You can't get or set the pipe size with getrlimit, so we have to
+	 cheat.  */
+    case u_PIPE_SIZE:
+      if (setting)
+	{
+	  errno = EINVAL;
+	  return ((RLIMTYPE)-1);
+	}
+      return (pipesize ());
+
+    case u_NUM_OPEN_FILES:
+      if (setting)
+	{
+#if defined (HAVE_RESOURCE) && defined (RLIMIT_NOFILE)
+	  cmd = RLIMIT_NOFILE;
+	  goto do_ulimit;
+#else
+#  if defined (HAVE_SETDTABLESIZE)
+	  return (setdtablesize (newlim));
+#  else
+	  errno = EINVAL;
+	  return ((RLIMTYPE)-1);
+#  endif /* HAVE_SETDTABLESIZE */
+#endif /* !HAVE_RESOURCE || !RLIMIT_NOFILE */
+	}
+      else
+	return (open_files (mode));
+
+    case u_MAX_VIRTUAL_MEM:
+      if (setting)
+	{
+	  errno = EINVAL;
+	  return ((RLIMTYPE)-1);
+	}
+      else
+	{
+#if defined (HAVE_RESOURCE)
+	  return (getmaxvm (mode));
+#else /* !HAVE_RESOURCE */
+	  errno = EINVAL;
+	  return ((RLIMTYPE)-1);
+#endif /* !HAVE_RESOURCE */
+	}
+
+    case u_MAX_USER_PROCS:
+#if defined (HAVE_RESOURCE) && defined (RLIMIT_NPROC)
+      cmd = RLIMIT_NPROC;
+      goto do_ulimit;
+#else /* !HAVE_RESOURCE || !RLIMIT_NPROC */
+      errno = EINVAL;
+      return ((RLIMTYPE)-1);
+#endif /* !HAVE_RESOURCE || !RLIMIT_NPROC */
+      
+    default:
+      errno = EINVAL;
+      return ((RLIMTYPE)-1);
+    }
+}
+
+#if defined (HAVE_RESOURCE)
+static RLIMTYPE
+getmaxvm (mode)
+     int mode;
+{
+  struct rlimit rl;
+
+#if defined (RLIMIT_VMEM)
+  if (getrlimit (RLIMIT_VMEM, &rl) < 0)
+    return ((RLIMTYPE)-1);
+  else
+    return (((mode & LIMIT_SOFT) ? rl.rlim_cur : rl.rlim_max) / 1024L);
+#else /* !RLIMIT_VMEM */
+  RLIMTYPE maxdata, maxstack;
+
+  if (getrlimit (RLIMIT_DATA, &rl) < 0)
+    return ((RLIMTYPE)-1);
+  else
+    maxdata = (mode & LIMIT_SOFT) ? rl.rlim_cur : rl.rlim_max;
+
+  if (getrlimit (RLIMIT_STACK, &rl) < 0)
+    return ((RLIMTYPE)-1);
+  else
+    maxstack = (mode & LIMIT_SOFT) ? rl.rlim_cur : rl.rlim_max;
+
+  /* Protect against overflow. */
+  return ((maxdata / 1024L) + (maxstack / 1024L));
+#endif /* !RLIMIT_VMEM */
+}
+#endif /* HAVE_RESOURCE */
+
+static RLIMTYPE
+open_files (mode)
+     int mode;
+{
+#if !defined (RLIMIT_NOFILE)
+  return ((RLIMTYPE)getdtablesize ());
+#else
+  struct rlimit rl;
+
+  getrlimit (RLIMIT_NOFILE, &rl);
+  if (mode & LIMIT_SOFT)
+    return (rl.rlim_cur);
+  else
+    return (rl.rlim_max);
+#endif
+}
+
+static RLIMTYPE
+pipesize ()
+{
+#if defined (PIPE_BUF)
+  /* This is defined on Posix systems. */
+  return ((RLIMTYPE) PIPE_BUF);
+#else
+#  if defined (PIPESIZE)
+  /* This is defined by running a program from the Makefile. */
+  return ((RLIMTYPE) PIPESIZE);
+#  else
+  errno = EINVAL;
+  return ((RLIMTYPE)-1);
+#  endif /* PIPESIZE */
+#endif /* PIPE_BUF */
+}
+
+/* ulimit(2) returns information about file size limits in terms of 512-byte
+   blocks.  This is the factor by which to divide to turn it into information
+   in terms of 1024-byte blocks.  Except for hpux 6.x, which returns it in
+   terms of bytes. */
+#if !defined (hpux) || defined (_POSIX_VERSION)
+#  define ULIMIT_DIVISOR 2
+#else
+#  define ULIMIT_DIVISOR 1024
+#endif
+
+#if defined (HAVE_RESOURCE)
+
+typedef struct {
+  int  option_cmd;		/* The ulimit command for this limit. */
+  int  parameter;		/* Parameter to pass to getrlimit (). */
+  int  block_factor;		/* Blocking factor for specific limit. */
+  char *description;		/* Descriptive string to output. */
+} BSD_RESOURCE_LIMITS;
+
+static BSD_RESOURCE_LIMITS limits[] = {
+  { u_CORE_FILE_SIZE, RLIMIT_CORE,  1024, "core file size (blocks)" },
+  { u_DATA_SEG_SIZE,  RLIMIT_DATA,  1024, "data seg size (kbytes)" },
+  { u_FILE_SIZE,      RLIMIT_FSIZE, 1024, "file size (blocks)" },
+#if !defined (USGr4) && defined (RLIMIT_RSS)
+  { u_PHYS_MEM_SIZE,  RLIMIT_RSS,   1024, "max memory size (kbytes)" },
+#endif /* USGr4 && RLIMIT_RSS */
+  { u_STACK_SIZE,     RLIMIT_STACK, 1024, "stack size (kbytes)" },
+#if defined (RLIMIT_CPU)
+  { u_CPU_TIME_LIMIT, RLIMIT_CPU,      1, "cpu time (seconds)" },
+#endif /* RLIMIT_CPU */
+#if defined (RLIMIT_NPROC)
+  { u_MAX_USER_PROCS, RLIMIT_NPROC,    1, "max user processes" },
+#endif /* RLIMIT_NPROC */
+  { 0, 0, 0, (char *)NULL }
+};
+
+static void
+print_bsd_limit (i, mode)
+     int i, mode;
+{
+  struct rlimit rl;
+  RLIMTYPE limit;
+
+  getrlimit (limits[i].parameter, &rl);
+  if (mode & LIMIT_HARD)
+    limit = rl.rlim_max;
+  else
+    limit = rl.rlim_cur;
+  printf ("%-25s", limits[i].description);
+  if (limit == RLIM_INFINITY)
+    printf ("unlimited\n");
+  else
+    print_rlimtype ((limit / limits[i].block_factor), 1);
+}
+
+static void
+print_specific_bsd_limits (cmd, mode)
+     int cmd, mode;
+{
+  register int i;
+
+  for (i = 0; limits[i].option_cmd; i++)
+    if (cmd & limits[i].option_cmd)
+      print_bsd_limit (i, mode);
+}
+#endif /* HAVE_RESOURCE */
+
+/* Print the limits corresponding to a specific set of resources.  This is
+   called when an option string contains more than one character (e.g. -at),
+   because limits may not be specified with that kind of argument. */
+static void
+print_specific_limits (cmd, mode)
+     int cmd, mode;
+{
+  if (mode == 0)
+    mode = LIMIT_SOFT;
+
+#if defined (HAVE_RESOURCE)
+  print_specific_bsd_limits (cmd, mode);
+#else /* !HAVE_RESOURCE */
+  if (cmd & u_FILE_SIZE)
+    {
+      printf ("%-25s", "file size (blocks)");
+      print_rlimtype ((ulimit (1, 0L) / ULIMIT_DIVISOR), 1);
+    }
+#endif /* !HAVE_RESOURCE */
+
+  if (cmd & u_PIPE_SIZE)
+    {
+      printf ("%-25s", "pipe size (512 bytes)");
+      print_rlimtype ((pipesize () / 512), 1);
+    }
+
+  if (cmd & u_NUM_OPEN_FILES)
+    {
+      printf ("%-25s", "open files");
+      print_rlimtype (open_files (mode), 1);
+    }
+
+#if defined (HAVE_RESOURCE)
+  if (cmd & u_MAX_VIRTUAL_MEM)
+    {
+      printf ("%-25s", "virtual memory (kbytes)");
+      print_rlimtype (getmaxvm (mode), 1);
+    }
+#endif /* HAVE_RESOURCE */
+}
+
+static void
+print_all_limits (mode)
+     int mode;
+{
+  if (mode == 0)
+    mode |= LIMIT_SOFT;
+
+  print_specific_limits (u_ALL_LIMITS, mode);
+}

builtins/umask.def

@@ -0,0 +1,288 @@
+This file is umask.def, from which is created umask.c.
+It implements the builtin "umask" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+$PRODUCES umask.c
+
+$BUILTIN umask
+$FUNCTION umask_builtin
+$SHORT_DOC umask [-S] [mode]
+The user file-creation mask is set to MODE.  If MODE is omitted, or if
+`-S' is supplied, the current value of the mask is printed.  The `-S'
+option makes the output symbolic; otherwise an octal number is output.
+If MODE begins with a digit, it is interpreted as an octal number,
+otherwise it is a symbolic mode string like that accepted by chmod(1).
+$END
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include "../shell.h"
+#include "../posixstat.h"
+#include "common.h"
+
+/* **************************************************************** */
+/*                                                                  */
+/*                     UMASK Builtin and Helpers                    */
+/*                                                                  */
+/* **************************************************************** */
+
+static void print_symbolic_umask ();
+static int symbolic_umask ();
+
+/* Set or display the mask used by the system when creating files.  Flag
+   of -S means display the umask in a symbolic mode. */
+umask_builtin (list)
+     WORD_LIST *list;
+{
+  int print_symbolically = 0;
+
+  while (list)
+    {
+      if (ISOPTION (list->word->word, 'S'))
+	{
+	  list = list->next;
+	  print_symbolically++;
+	  continue;
+	}
+      else if (ISOPTION (list->word->word, '-'))
+	{
+	  list = list->next;
+	  break;
+	}
+      else if (*(list->word->word) == '-')
+	{
+	  bad_option (list->word->word);
+	  builtin_error ("usage: umask [-S] [mode]");
+	  return (EX_USAGE);
+	}
+      else
+	break;
+    }
+
+  if (list)
+    {
+      int new_umask;
+
+      if (digit (*list->word->word))
+	{
+	  new_umask = read_octal (list->word->word);
+
+	  /* Note that other shells just let you set the umask to zero
+	     by specifying a number out of range.  This is a problem
+	     with those shells.  We don't change the umask if the input
+	     is lousy. */
+	  if (new_umask == -1)
+	    {
+	      builtin_error ("`%s' is not an octal number from 000 to 777",
+				list->word->word);
+	      return (EXECUTION_FAILURE);
+	    }
+	}
+      else
+	{
+	  new_umask = symbolic_umask (list);
+	  if (new_umask == -1)
+	    return (EXECUTION_FAILURE);
+	}
+      umask (new_umask);
+      if (print_symbolically)
+	print_symbolic_umask (new_umask);
+    }
+  else				/* Display the UMASK for this user. */
+    {
+      int old_umask;
+
+      old_umask = umask (022);
+      umask (old_umask);
+
+      if (print_symbolically)
+	print_symbolic_umask (old_umask);
+      else
+	printf ("%03o\n", old_umask);
+    }
+  fflush (stdout);
+  return (EXECUTION_SUCCESS);
+}
+
+/* Print the umask in a symbolic form.  In the output, a letter is
+   printed if the corresponding bit is clear in the umask. */
+static void
+print_symbolic_umask (um)
+     int um;
+{
+  char ubits[4], gbits[4], obits[4];		/* u=rwx,g=rwx,o=rwx */
+  int i;
+
+  i = 0;
+  if ((um & S_IRUSR) == 0)
+    ubits[i++] = 'r';
+  if ((um & S_IWUSR) == 0)
+    ubits[i++] = 'w';
+  if ((um & S_IXUSR) == 0)
+    ubits[i++] = 'x';
+  ubits[i] = '\0';
+
+  i = 0;
+  if ((um & S_IRGRP) == 0)
+    gbits[i++] = 'r';
+  if ((um & S_IWGRP) == 0)
+    gbits[i++] = 'w';
+  if ((um & S_IXGRP) == 0)
+    gbits[i++] = 'x';
+  gbits[i] = '\0';
+
+  i = 0;
+  if ((um & S_IROTH) == 0)
+    obits[i++] = 'r';
+  if ((um & S_IWOTH) == 0)
+    obits[i++] = 'w';
+  if ((um & S_IXOTH) == 0)
+    obits[i++] = 'x';
+  obits[i] = '\0';
+
+  printf ("u=%s,g=%s,o=%s\n", ubits, gbits, obits);
+}
+
+/* Set the umask from a symbolic mode string similar to that accepted
+   by chmod.  If the -S argument is given, then print the umask in a
+   symbolic form. */
+static int
+symbolic_umask (list)
+     WORD_LIST *list;
+{
+  int um, umc, c;
+  int who, op, perm, mask;
+  char *s;
+
+  /* Get the initial umask.  Don't change it yet. */
+  um = umask (022);
+  umask (um);
+
+  /* All work below is done with the complement of the umask -- its
+     more intuitive and easier to deal with.  It is complemented
+     again before being returned. */
+  umc = ~um;
+
+  s = list->word->word;
+
+  for (;;)
+    {
+      who = op = perm = mask = 0;
+
+      /* Parse the `who' portion of the symbolic mode clause. */
+      while (member (*s, "agou"))
+        {
+	  switch (c = *s++)
+	    {
+	      case 'u':
+	        who |= S_IRWXU;
+	        continue;
+	      case 'g':
+	        who |= S_IRWXG;
+	        continue;
+	      case 'o':
+	        who |= S_IRWXO;
+	        continue;
+	      case 'a':
+	        who |= S_IRWXU | S_IRWXG | S_IRWXO;
+	        continue;
+	      default:
+	        break;
+	    }
+	}
+
+      /* The operation is now sitting in *s. */
+      op = *s++;
+      switch (op)
+	{
+	  case '+':
+	  case '-':
+	  case '=':
+	    break;
+	  default:
+	    builtin_error ("bad symbolic mode operator: %c", op);
+	    return (-1);
+	}
+
+      /* Parse out the `perm' section of the symbolic mode clause. */
+      while (member (*s, "rwx"))
+	{
+	  c = *s++;
+
+	  switch (c)
+	    {
+	      case 'r':
+		perm |= S_IRUGO;
+		break;
+
+	      case 'w':
+		perm |= S_IWUGO;
+		break;
+
+	      case 'x':
+		perm |= S_IXUGO;
+		break;
+	    }
+	}
+
+      /* Now perform the operation or return an error for a
+	 bad permission string. */
+      if (!*s || *s == ',')
+	{
+	  if (who)
+	    perm &= who;
+
+	  switch (op)
+	    {
+	      case '+':
+	        umc |= perm;
+	        break;
+
+	      case '-':
+	        umc &= ~perm;
+	        break;
+
+	      case '=':
+	        umc &= ~who;
+	        umc |= perm;
+	        break;
+
+	      default:
+	      	builtin_error ("bad operation character: %c", op);
+	      	return (-1);
+	    }
+
+	  if (!*s)
+	    {
+	      um = ~umc & 0777;
+	      break;
+	    }
+	  else
+	    s++;	/* skip past ',' */
+	}
+      else
+	{
+	  builtin_error ("bad character in symbolic mode: %c", *s);
+	  return (-1);
+	}
+    }
+  return (um);
+}

builtins/wait.def

@@ -0,0 +1,132 @@
+This file is wait.def, from which is created wait.c.
+It implements the builtin "wait" 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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+$BUILTIN wait
+$FUNCTION wait_builtin
+$DEPENDS_ON JOB_CONTROL
+$PRODUCES wait.c
+$SHORT_DOC wait [n]
+Wait for the specified process and report its termination status.  If
+N is not given, all currently active child processes are waited for,
+and the return code is zero.  N may be a process ID or a job
+specification; if a job spec is given, all processes in the job's
+pipeline are waited for.
+$END
+
+$BUILTIN wait
+$FUNCTION wait_builtin
+$DEPENDS_ON !JOB_CONTROL
+$SHORT_DOC wait [n]
+Wait for the specified process and report its termination status.  If
+N is not given, all currently active child processes are waited for,
+and the return code is zero.  N is a process ID; if it is not given,
+all child processes of the shell are waited for.
+$END
+
+#include <sys/types.h>
+#include <signal.h>
+#include "../shell.h"
+#include "../jobs.h"
+
+extern int interrupt_immediately;
+
+/* Wait for the pid in LIST to stop or die.  If no arguments are given, then
+   wait for all of the active background processes of the shell and return
+   0.  If a list of pids or job specs are given, return the exit status of
+   the last one waited for. */
+wait_builtin (list)
+     WORD_LIST *list;
+{
+  int status = EXECUTION_SUCCESS;
+
+  begin_unwind_frame ("wait_builtin");
+  unwind_protect_int (interrupt_immediately);
+  interrupt_immediately++;
+
+  /* We support jobs or pids.
+     wait <pid-or-job> [pid-or-job ...] */
+
+  /* But wait without any arguments means to wait for all of the shell's
+     currently active background processes. */
+  if (!list)
+    {
+      wait_for_background_pids ();
+      status = EXECUTION_SUCCESS;
+      goto return_status;
+    }
+
+  while (list)
+    {
+      pid_t pid;
+      char *w;
+
+      w = list->word->word;
+      if (digit (*w))
+	{
+	  if (all_digits (w + 1))
+	    {
+	      pid = (pid_t)atoi (w);
+	      status = wait_for_single_pid (pid);
+	    }
+	  else
+	    {
+	      builtin_error ("`%s' is not a pid or legal job spec", w);
+	      status = EXECUTION_FAILURE;
+	      goto return_status;
+	    }
+	}
+#if defined (JOB_CONTROL)
+      else if (job_control && *w)
+	/* Must be a job spec.  Check it out. */
+	{
+	  int job;
+	  sigset_t set, oset;
+
+	  BLOCK_CHILD (set, oset);
+	  job = get_job_spec (list);
+
+	  if (job < 0 || job >= job_slots || !jobs[job])
+	    {
+	      if (job != DUP_JOB)
+		builtin_error ("No such job %s", list->word->word);
+	      UNBLOCK_CHILD (oset);
+	      status = 127;	/* As per Posix.2, section 4.70.2 */
+	      list = list->next;
+	      continue;
+	    }
+
+	  /* Job spec used.  Wait for the last pid in the pipeline. */
+	  UNBLOCK_CHILD (oset);
+	  status = wait_for_job (job);
+	}
+#endif /* JOB_CONTROL */
+      else
+	{
+	  builtin_error ("`%s' is not a pid or legal job spec", w);
+	  status = EXECUTION_FAILURE;
+	}
+      list = list->next;
+    }
+ return_status:
+  run_unwind_frame ("wait_builtin");
+  return (status);
+}

command.h

@@ -0,0 +1,215 @@
+/* command.h -- The structures used internally to represent commands, and
+   the extern declarations of the functions used to create them. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (_COMMAND_H)
+#define _COMMAND_H
+
+#include "stdc.h"
+
+/* Instructions describing what kind of thing to do for a redirection. */
+enum r_instruction {
+  r_output_direction, r_input_direction, r_inputa_direction,
+  r_appending_to, r_reading_until, r_duplicating_input,
+  r_duplicating_output, r_deblank_reading_until, r_close_this,
+  r_err_and_out, r_input_output, r_output_force,
+  r_duplicating_input_word, r_duplicating_output_word
+};
+
+/* Command Types: */
+enum command_type { cm_for, cm_case, cm_while, cm_if, cm_simple, cm_select,
+		    cm_connection, cm_function_def, cm_until, cm_group };
+
+/* A structure which represents a word. */
+typedef struct word_desc {
+  char *word;		/* Zero terminated string. */
+  int dollar_present;	/* Non-zero means dollar sign present. */
+  int quoted;		/* Non-zero means single, double, or back quote
+			   or backslash is present. */
+  int assignment;	/* Non-zero means that this word contains an
+			   assignment. */
+} WORD_DESC;
+
+/* A linked list of words. */
+typedef struct word_list {
+  struct word_list *next;
+  WORD_DESC *word;
+} WORD_LIST;
+
+
+/* **************************************************************** */
+/*								    */
+/*			Shell Command Structs			    */
+/*								    */
+/* **************************************************************** */
+
+/* What a redirection descriptor looks like.  If FLAGS is IS_DESCRIPTOR,
+   then we use REDIRECTEE.DEST, else we use the file specified. */
+
+typedef union {
+  long dest;			/* Place to redirect REDIRECTOR to, or ... */
+  WORD_DESC *filename;		/* filename to redirect to. */
+} REDIRECTEE;
+
+typedef struct redirect {
+  struct redirect *next;	/* Next element, or NULL. */
+  int redirector;		/* Descriptor to be redirected. */
+  int flags;			/* Flag value for `open'. */
+  enum r_instruction  instruction; /* What to do with the information. */
+  REDIRECTEE redirectee;	/* File descriptor or filename */
+  char *here_doc_eof;		/* The word that appeared in <<foo. */
+} REDIRECT;
+
+/* An element used in parsing.  A single word or a single redirection.
+   This is an ephemeral construct. */
+typedef struct element {
+  WORD_DESC *word;
+  REDIRECT *redirect;
+} ELEMENT;
+
+/* Possible values for command->flags. */
+#define CMD_WANT_SUBSHELL  0x01	/* User wants a subshell: ( command ) */
+#define CMD_FORCE_SUBSHELL 0x02	/* Shell needs to force a subshell. */
+#define CMD_INVERT_RETURN  0x04	/* Invert the exit value. */
+#define CMD_IGNORE_RETURN  0x08	/* Ignore the exit value.  For set -e. */
+#define CMD_NO_FUNCTIONS   0x10 /* Ignore functions during command lookup. */
+#define CMD_INHIBIT_EXPANSION 0x20 /* Do not expand the command words. */
+#define CMD_NO_FORK	   0x40	/* Don't fork; just call execve */
+
+/* What a command looks like. */
+typedef struct command {
+  enum command_type type;	/* FOR CASE WHILE IF CONNECTION or SIMPLE. */
+  int flags;			/* Flags controlling execution environment. */
+  int line;			/* line number the command starts on */
+  REDIRECT *redirects;		/* Special redirects for FOR CASE, etc. */
+  union {
+    struct for_com *For;
+    struct case_com *Case;
+    struct while_com *While;
+    struct if_com *If;
+    struct connection *Connection;
+    struct simple_com *Simple;
+    struct function_def *Function_def;
+    struct group_com *Group;
+#if defined (SELECT_COMMAND)
+    struct select_com *Select;
+#endif
+  } value;
+} COMMAND;
+
+/* Structure used to represent the CONNECTION type. */
+typedef struct connection {
+  int ignore;			/* Unused; simplifies make_command (). */
+  COMMAND *first;		/* Pointer to the first command. */
+  COMMAND *second;		/* Pointer to the second command. */
+  int connector;		/* What separates this command from others. */
+} CONNECTION;
+
+/* Structures used to represent the CASE command. */
+
+/* Pattern/action structure for CASE_COM. */
+typedef struct pattern_list {
+  struct pattern_list *next;	/* Clause to try in case this one failed. */
+  WORD_LIST *patterns;		/* Linked list of patterns to test. */
+  COMMAND *action;		/* Thing to execute if a pattern matches. */
+} PATTERN_LIST;
+
+/* The CASE command. */
+typedef struct case_com {
+  int flags;			/* See description of CMD flags. */
+  WORD_DESC *word;		/* The thing to test. */
+  PATTERN_LIST *clauses;	/* The clauses to test against, or NULL. */
+} CASE_COM;
+
+/* FOR command. */
+typedef struct for_com {
+  int flags;		/* See description of CMD flags. */
+  WORD_DESC *name;	/* The variable name to get mapped over. */
+  WORD_LIST *map_list;	/* The things to map over.  This is never NULL. */
+  COMMAND *action;	/* The action to execute.
+			   During execution, NAME is bound to successive
+			   members of MAP_LIST. */
+} FOR_COM;
+
+#if defined (SELECT_COMMAND)
+/* KSH SELECT command. */
+typedef struct select_com {
+  int flags;		/* See description of CMD flags. */
+  WORD_DESC *name;	/* The variable name to get mapped over. */
+  WORD_LIST *map_list;	/* The things to map over.  This is never NULL. */
+  COMMAND *action;	/* The action to execute.
+			   During execution, NAME is bound to the member of
+			   MAP_LIST chosen by the user. */
+} SELECT_COM;
+#endif /* SELECT_COMMAND */
+
+/* IF command. */
+typedef struct if_com {
+  int flags;			/* See description of CMD flags. */
+  COMMAND *test;		/* Thing to test. */
+  COMMAND *true_case;		/* What to do if the test returned non-zero. */
+  COMMAND *false_case;		/* What to do if the test returned zero. */
+} IF_COM;
+
+/* WHILE command. */
+typedef struct while_com {
+  int flags;			/* See description of CMD flags. */
+  COMMAND *test;		/* Thing to test. */
+  COMMAND *action;		/* Thing to do while test is non-zero. */
+} WHILE_COM;
+
+/* The "simple" command.  Just a collection of words and redirects. */
+typedef struct simple_com {
+  int flags;			/* See description of CMD flags. */
+  WORD_LIST *words;		/* The program name, the arguments,
+				   variable assignments, etc. */
+  REDIRECT *redirects;		/* Redirections to perform. */
+  int line;			/* line number the command starts on */
+} SIMPLE_COM;
+
+/* The "function_def" command.  This isn't really a command, but it is
+   represented as such for now.  If the function def appears within 
+   `(' `)' the parser tries to set the SUBSHELL bit of the command.  That
+   means that FUNCTION_DEF has to be run through the executor.  Maybe this
+   command should be defined in a subshell.  Who knows or cares. */
+typedef struct function_def {
+  int ignore;			/* See description of CMD flags. */
+  WORD_DESC *name;		/* The name of the function. */
+  COMMAND *command;		/* The parsed execution tree. */
+} FUNCTION_DEF;
+
+/* A command that is `grouped' allows pipes to take effect over
+   the entire command structure. */
+typedef struct group_com {
+  int ignore;			/* See description of CMD flags. */
+  COMMAND *command;
+} GROUP_COM;
+
+extern COMMAND *global_command;
+
+/* Forward declarations of functions declared in copy_cmd.c. */
+
+extern WORD_DESC *copy_word __P((WORD_DESC *));
+extern WORD_LIST *copy_word_list __P((WORD_LIST *));
+extern REDIRECT *copy_redirect __P((REDIRECT *));
+extern REDIRECT *copy_redirects __P((REDIRECT *));
+extern COMMAND *copy_command __P((COMMAND *));
+
+#endif /* _COMMAND_H */

config.h

@@ -0,0 +1,186 @@
+/* config.h -- Configuration file for bash. */
+
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (_CONFIG_H_)
+#define _CONFIG_H_
+
+#if !defined (BUILDING_MAKEFILE)
+#include "memalloc.h"
+#endif
+
+#if defined (HAVE_UNISTD_H) && !defined (BUILDING_MAKEFILE)
+#  ifdef CRAY
+#    define word __word
+#  endif
+#include <unistd.h>
+#  ifdef CRAY
+#    undef word
+#  endif
+#endif
+
+/* Define JOB_CONTROL if your operating system supports
+   BSD-like job control. */
+#define JOB_CONTROL
+
+/* Note that vanilla System V machines don't support BSD job control,
+   although some do support Posix job control. */
+#if defined (USG) || defined (MINIX) || defined (Minix)
+#  if !defined (_POSIX_JOB_CONTROL)
+#    undef JOB_CONTROL
+#  endif /* !_POSIX_JOB_CONTROL */
+#endif /* USG || Minix || MINIX */
+
+/* Define ALIAS if you want the alias features. */
+#define ALIAS
+
+/* Define PUSHD_AND_POPD if you want those commands to be compiled in.
+   (Also the `dirs' commands.) */
+#define PUSHD_AND_POPD
+
+/* Define BRACE_EXPANSION if you want curly brace expansion a la Csh:
+   foo{a,b} -> fooa foob.  Even if this is compiled in (the default) you
+   can turn it off at shell startup with `-nobraceexpansion', or during
+   shell execution with `set +o braceexpand'. */
+#define BRACE_EXPANSION
+
+/* Define READLINE to get the nifty/glitzy editing features.
+   This is on by default.  You can turn it off interactively
+   with the -nolineediting flag. */
+#define READLINE
+
+/* Define BANG_HISTORY if you want to have Csh style "!" history expansion.
+   This is unrelated to READLINE. */
+#define BANG_HISTORY
+
+/* Define HISTORY if you want to have access to previously typed commands.
+
+   If both HISTORY and READLINE are defined, you can get at the commands
+   with line editing commands, and you can directly manipulate the history
+   from the command line.
+
+   If only HISTORY is defined, the `fc' and `history' builtins are
+   available. */
+#define HISTORY
+
+#if defined (BANG_HISTORY) && !defined (HISTORY)
+   /* BANG_HISTORY requires HISTORY. */
+#  define HISTORY
+#endif /* BANG_HISTORY && !HISTORY */
+
+#if defined (READLINE) && !defined (HISTORY)
+#  define HISTORY
+#endif
+
+/* The default value of the PATH variable. */
+#define DEFAULT_PATH_VALUE \
+  "/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin:."
+
+/* The value for PATH when invoking `command -p'.  This is only used when
+   the Posix.2 confstr () function, or CS_PATH define are not present. */
+#define STANDARD_UTILS_PATH \
+  "/bin:/usr/bin:/usr/ucb:/usr/sbin:/sbin:/etc:/usr/etc:/usr/lib"
+
+/* Put system-specific default mail directories here. */
+#if defined (__bsdi__) || defined (__FreeBSD__) || defined (__NetBSD__)
+#  define DEFAULT_MAIL_PATH "/var/mail/"
+#endif
+
+#if !defined (DEFAULT_MAIL_PATH)
+#if defined (USG)
+#  define DEFAULT_MAIL_PATH "/usr/mail/"
+#else
+#  define DEFAULT_MAIL_PATH "/usr/spool/mail/"
+#endif
+#endif
+
+/* Define V9_ECHO if you want to give the echo builtin backslash-escape
+   interpretation using the -e option, in the style of the Bell Labs 9th
+   Edition version of echo. */
+#define V9_ECHO
+
+/* Define DEFAULT_ECHO_TO_USG if you want the echo builtin to interpret
+   the backslash-escape characters by default, like the System V echo.
+   This requires that V9_ECHO be defined. */
+/* #define DEFAULT_ECHO_TO_USG */
+#if !defined (V9_ECHO)
+#  undef DEFAULT_ECHO_TO_USG
+#endif
+
+/* Define CONTINUE_AFTER_KILL_ERROR if you want the kill command to
+   continue processing arguments after one of them fails. */
+#define CONTINUE_AFTER_KILL_ERROR
+
+/* Define BREAK_COMPLAINS if you want the non-standard, but useful
+   error messages about `break' and `continue' out of context. */
+#define BREAK_COMPLAINS
+
+/* Define GETOPTS_BUILTIN if you want the Posix.2 `getopts' shell builtin
+   compiled into the shell. */
+#define GETOPTS_BUILTIN
+
+/* When ALLOW_RIGID_POSIX_COMPLIANCE is defined, you can turn on strictly
+   Posix compliant behaviour by setting the environment variable
+   POSIXLY_CORRECT. */
+#define ALLOW_RIGID_POSIX_COMPLIANCE
+
+/* Define RESTRICTED_SHELL if you want the generated shell to have the
+   ability to be a restricted one.  The shell thus generated can become
+   restricted by being run with the name "rbash", or by setting the -r
+   flag. */
+/* #define RESTRICTED_SHELL */
+
+/* Define DISABLED_BUILTINS if you want "builtin foo" to always run the
+   shell builtin "foo", even if it has been disabled with "enable -n foo". */
+/* #define DISABLED_BUILTINS */
+
+/* Define PROCESS_SUBSTITUTION if you want the K*rn shell-like process
+   substitution features "<(file)". */
+/* Right now, you cannot do this on machines without fully operational
+   FIFO support.  This currently include NeXT and Alliant. */
+#if !defined (MKFIFO_MISSING) || defined (HAVE_DEV_FD)
+#  define PROCESS_SUBSTITUTION
+#endif /* !MKFIFO_MISSING */
+
+/* Define PROMPT_STRING_DECODE if you want the backslash-escaped special
+   characters in PS1 and PS2 expanded.  Variable expansion will still be
+   performed. */
+#define PROMPT_STRING_DECODE
+
+/* Define BUFFERED_INPUT if you want the shell to do its own input
+   buffering. */
+#define BUFFERED_INPUT
+
+/* Define INTERACTIVE_COMMENTS if you want # comments to work by default
+   when the shell is interactive, as Posix.2a specifies. */
+#define INTERACTIVE_COMMENTS
+
+/* Define ONESHOT if you want sh -c 'command' to avoid forking to execute
+   `command' whenever possible. */
+#define ONESHOT
+
+/* Default primary and secondary prompt strings. */
+#define PPROMPT "bash\\$ "
+#define SPROMPT "> "
+
+/* Define SELECT_COMMAND if you want the Korn-shell style `select' command:
+	select word in word_list; do command_list; done */
+#define SELECT_COMMAND
+
+#endif	/* !_CONFIG_H_ */

config.h.mini

@@ -0,0 +1,194 @@
+/* config.h -- Configuration file for bash. */
+
+/* This is a `minimal' configuration file.  It will create a shell without:
+	job control
+	aliases
+	pushd and popd
+	readline
+	history
+	restricted shell mode
+	`disabled' builtins (builtin xxx finds xxx even after enable -n xxx)
+	process substitution
+	prompt string decoding (though variable expansion is still done)
+	the `select' command */
+	
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (_CONFIG_H_)
+#define _CONFIG_H_
+
+#include "memalloc.h"
+
+#if defined (HPUX) || defined (UNIXPC) || defined (Xenix)
+#  if !defined (USG)
+#    define USG
+#  endif
+#endif
+
+#if defined (HAVE_UNISTD_H) && !defined (BUILDING_MAKEFILE)
+#include <unistd.h>
+#endif
+
+/* Define JOB_CONTROL if your operating system supports
+   BSD-like job control. */
+/* #define JOB_CONTROL */
+
+/* Note that vanilla System V machines don't support BSD job control,
+   although some do support Posix job control. */
+#if defined (USG) && !defined (_POSIX_JOB_CONTROL)
+#  undef JOB_CONTROL
+#endif /* USG && !_POSIX_JOB_CONTROL */
+
+/* Define ALIAS if you want the alias features. */
+/* #define ALIAS */
+
+/* Define PUSHD_AND_POPD if you want those commands to be compiled in.
+   (Also the `dirs' commands.) */
+/* #define PUSHD_AND_POPD */
+
+/* Define BRACE_EXPANSION if you want curly brace expansion a la Csh:
+   foo{a,b} -> fooa foob.  Even if this is compiled in (the default) you
+   can turn it off at shell startup with `-nobraceexpansion', or during
+   shell execution with `set +o braceexpand'. */
+/* #define BRACE_EXPANSION */
+
+/* Define READLINE to get the nifty/glitzy editing features.
+   This is on by default.  You can turn it off interactively
+   with the -nolineediting flag. */
+/* #define READLINE */
+
+/* Define BANG_HISTORY if you want to have Csh style "!" history expansion.
+   This is unrelated to READLINE. */
+/* #define BANG_HISTORY */
+
+/* Define HISTORY if you want to have access to previously typed commands.
+
+   If both HISTORY and READLINE are defined, you can get at the commands
+   with line editing commands, and you can directly manipulate the history
+   from the command line.
+
+   If only HISTORY is defined, the `fc' and `history' builtins are
+   available. */
+/* #define HISTORY */
+
+#if defined (BANG_HISTORY) && !defined (HISTORY)
+   /* BANG_HISTORY requires HISTORY. */
+#  define HISTORY
+#endif /* BANG_HISTORY && !HISTORY */
+
+#if defined (READLINE) && !defined (HISTORY)
+#  define HISTORY
+#endif
+
+/* The default value of the PATH variable. */
+#define DEFAULT_PATH_VALUE \
+  "/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin:."
+
+/* The value for PATH when invoking `command -p'.  This is only used when
+   the Posix.2 confstr () function, or CS_PATH define are not present. */
+#define STANDARD_UTILS_PATH \
+  "/bin:/usr/bin:/usr/ucb:/usr/sbin:/sbin:/etc:/usr/etc:/usr/lib"
+
+/* Put system-specific default mail directories here. */
+#if defined (__bsdi__) || defined (__FreeBSD__) || defined (__NetBSD__)
+#  define DEFAULT_MAIL_PATH "/var/mail/"
+#endif
+
+#if !defined (DEFAULT_MAIL_PATH)
+#if defined (USG)
+#  define DEFAULT_MAIL_PATH "/usr/mail/"
+#else
+#  define DEFAULT_MAIL_PATH "/usr/spool/mail/"
+#endif
+#endif
+
+/* Define V9_ECHO if you want to give the echo builtin backslash-escape
+   interpretation using the -e option, in the style of the Bell Labs 9th
+   Edition version of echo. */
+#define V9_ECHO
+
+/* Define DEFAULT_ECHO_TO_USG if you want the echo builtin to interpret
+   the backslash-escape characters by default, like the System V echo.
+   This requires that V9_ECHO be defined. */
+/* #define DEFAULT_ECHO_TO_USG */
+#if !defined (V9_ECHO)
+#  undef DEFAULT_ECHO_TO_USG
+#endif
+
+/* Define CONTINUE_AFTER_KILL_ERROR if you want the kill command to
+   continue processing arguments after one of them fails. */
+#define CONTINUE_AFTER_KILL_ERROR
+
+/* Define BREAK_COMPLAINS if you want the non-standard, but useful
+   error messages about `break' and `continue' out of context. */
+#define BREAK_COMPLAINS
+
+/* Define GETOPTS_BUILTIN if you want the Posix.2 `getopts' shell builtin
+   compiled into the shell. */
+#define GETOPTS_BUILTIN
+
+/* When ALLOW_RIGID_POSIX_COMPLIANCE is defined, you can turn on strictly
+   Posix compliant behaviour by setting the environment variable
+   POSIXLY_CORRECT. */
+#define ALLOW_RIGID_POSIX_COMPLIANCE
+
+/* Define RESTRICTED_SHELL if you want the generated shell to have the
+   ability to be a restricted one.  The shell thus generated can become
+   restricted by being run with the name "rbash", or by setting the -r
+   flag. */
+/* #define RESTRICTED_SHELL */
+
+/* Define DISABLED_BUILTINS if you want "builtin foo" to always run the
+   shell builtin "foo", even if it has been disabled with "enable -n foo". */
+/* #define DISABLED_BUILTINS */
+
+/* Define PROCESS_SUBSTITUTION if you want the K*rn shell-like process
+   substitution features "<(file)". */
+/* Right now, you cannot do this on machines without fully operational
+   FIFO support.  This currently include NeXT and Alliant. */
+#if !defined (MKFIFO_MISSING)
+#  define PROCESS_SUBSTITUTION
+#endif /* !MKFIFO_MISSING */
+
+/* Define PROMPT_STRING_DECODE if you want the backslash-escaped special
+   characters in PS1 and PS2 expanded.  Variable expansion will still be
+   performed. */
+/* #define PROMPT_STRING_DECODE */
+
+/* Define BUFFERED_INPUT if you want the shell to do its own input
+   buffering. */
+#define BUFFERED_INPUT
+
+/* Define INTERACTIVE_COMMENTS if you want # comments to work by default
+   when the shell is interactive, as Posix.2a specifies. */
+#define INTERACTIVE_COMMENTS
+
+/* Define ONESHOT if you want sh -c 'command' to avoid forking to execute
+   `command' whenever possible. */
+#define ONESHOT
+
+/* Default primary and secondary prompt strings. */
+#define PPROMPT "bash\\$ "
+#define SPROMPT "> "
+
+/* Define SELECT_COMMAND if you want the Korn-shell style `select' command:
+	select word in word_list; do command_list; done */
+/* #define SELECT_COMMAND */
+
+#endif	/* !_CONFIG_H_ */

configure

@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# This shell script does nothing since Bash doesn't require
+# configuration to be forced on it; it auto-configures.  You can
+# change the location of the source directory with +srcdir.
+#
+echo "Bash is configured to auto configure."
+exit 0

copy_cmd.c

@@ -0,0 +1,305 @@
+/* copy_command.c -- copy a COMMAND structure.  This is needed
+   primarily for making function definitions, but I'm not sure
+   that anyone else will need it.  */
+
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include <stdio.h>
+
+#if defined (HAVE_STRING_H)
+#  include <string.h>
+#else /* !HAVE_STRING_H */
+#  include <strings.h>
+#endif /* !HAVE_STRING_H */
+
+#include "shell.h"
+
+WORD_DESC *
+copy_word (word)
+     WORD_DESC *word;
+{
+  WORD_DESC *new_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
+  FASTCOPY ((char *)word, (char *)new_word, sizeof (WORD_DESC));
+  new_word->word = savestring (word->word);
+  return (new_word);
+}
+
+/* Copy the chain of words in LIST.  Return a pointer to 
+   the new chain. */
+WORD_LIST *
+copy_word_list (list)
+     WORD_LIST *list;
+{
+  WORD_LIST *new_list = NULL;
+
+  while (list)
+    {
+      WORD_LIST *temp = (WORD_LIST *)xmalloc (sizeof (WORD_LIST));
+      temp->next = new_list;
+      new_list = temp;
+      new_list->word = copy_word (list->word);
+      list = list->next;
+    }
+  return (REVERSE_LIST (new_list, WORD_LIST *));
+}
+
+static PATTERN_LIST *
+copy_case_clause (clause)
+     PATTERN_LIST *clause;
+{
+  PATTERN_LIST *new_clause = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
+  new_clause->patterns = copy_word_list (clause->patterns);
+  new_clause->action = copy_command (clause->action);
+  return (new_clause);
+}
+
+static PATTERN_LIST *
+copy_case_clauses (clauses)
+     PATTERN_LIST *clauses;
+{
+  PATTERN_LIST *new_list = (PATTERN_LIST *)NULL;
+
+  while (clauses)
+    {
+      PATTERN_LIST *new_clause = copy_case_clause (clauses);
+      new_clause->next = new_list;
+      new_list = new_clause;
+      clauses = clauses->next;
+    }
+  return (REVERSE_LIST (new_list, PATTERN_LIST *));
+}
+
+/* Copy a single redirect. */
+REDIRECT *
+copy_redirect (redirect)
+     REDIRECT *redirect;
+{
+  REDIRECT *new_redirect = (REDIRECT *)xmalloc (sizeof (REDIRECT));
+  FASTCOPY ((char *)redirect, (char *)new_redirect, (sizeof (REDIRECT)));
+  switch (redirect->instruction)
+    {
+    case r_reading_until:
+    case r_deblank_reading_until:
+      new_redirect->here_doc_eof = savestring (redirect->here_doc_eof);
+      /* There is NO BREAK HERE ON PURPOSE!!!! */
+    case r_appending_to:
+    case r_output_direction:
+    case r_input_direction:
+    case r_inputa_direction:
+    case r_err_and_out:
+    case r_input_output:
+    case r_output_force:
+    case r_duplicating_input_word:
+    case r_duplicating_output_word:
+      new_redirect->redirectee.filename =
+	copy_word (redirect->redirectee.filename);
+      break;
+    }
+  return (new_redirect);
+}
+  
+REDIRECT *
+copy_redirects (list)
+     REDIRECT *list;
+{
+  REDIRECT *new_list = NULL;
+
+  while (list)
+    {
+      REDIRECT *temp = copy_redirect (list);
+      temp->next = new_list;
+      new_list = temp;
+      list = list->next;
+    }
+  return (REVERSE_LIST (new_list, REDIRECT *));
+}
+  
+static FOR_COM *
+copy_for_command (com)
+     FOR_COM *com;
+{
+  FOR_COM *new_for = (FOR_COM *)xmalloc (sizeof (FOR_COM));
+  new_for->flags = com->flags;
+  new_for->name = copy_word (com->name);
+  new_for->map_list = copy_word_list (com->map_list);
+  new_for->action = copy_command (com->action);
+  return (new_for);
+}
+
+#if defined (SELECT_COMMAND)
+static SELECT_COM *
+copy_select_command (com)
+     SELECT_COM *com;
+{
+  SELECT_COM *new_select = (SELECT_COM *)xmalloc (sizeof (SELECT_COM));
+  new_select->flags = com->flags;
+  new_select->name = copy_word (com->name);
+  new_select->map_list = copy_word_list (com->map_list);
+  new_select->action = copy_command (com->action);
+  return (new_select);
+}
+#endif /* SELECT_COMMAND */
+
+static GROUP_COM *
+copy_group_command (com)
+     GROUP_COM *com;
+{
+  GROUP_COM *new_group = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
+
+  new_group->command = copy_command (com->command);
+  return (new_group);
+}
+
+static CASE_COM *
+copy_case_command (com)
+     CASE_COM *com;
+{
+  CASE_COM *new_case = (CASE_COM *)xmalloc (sizeof (CASE_COM));
+
+  new_case->flags = com->flags;
+  new_case->word = copy_word (com->word);
+  new_case->clauses = copy_case_clauses (com->clauses);
+  return (new_case);
+}
+
+static WHILE_COM *
+copy_while_command (com)
+     WHILE_COM *com;
+{
+  WHILE_COM *new_while = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
+
+  new_while->flags = com->flags;
+  new_while->test = copy_command (com->test);
+  new_while->action = copy_command (com->action);
+  return (new_while);
+}
+
+static IF_COM *
+copy_if_command (com)
+     IF_COM *com;
+{
+  IF_COM *new_if = (IF_COM *)xmalloc (sizeof (IF_COM));
+
+  new_if->flags = com->flags;
+  new_if->test = copy_command (com->test);
+  new_if->true_case = copy_command (com->true_case);
+  new_if->false_case = copy_command (com->false_case);
+  return (new_if);
+}
+
+static SIMPLE_COM *
+copy_simple_command (com)
+     SIMPLE_COM *com;
+{
+  SIMPLE_COM *new_simple = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
+
+  new_simple->flags = com->flags;
+  new_simple->words = copy_word_list (com->words);
+  new_simple->redirects = copy_redirects (com->redirects);
+  new_simple->line = com->line;
+  return (new_simple);
+}
+
+static FUNCTION_DEF *
+copy_function_def (com)
+     FUNCTION_DEF *com;
+{
+  FUNCTION_DEF *new_def = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
+
+  new_def->name = copy_word (com->name);
+  new_def->command = copy_command (com->command);
+  return (new_def);
+}
+
+/* Copy the command structure in COMMAND.  Return a pointer to the
+   copy.  Don't you forget to dispose_command () on this pointer
+   later! */
+COMMAND *
+copy_command (command)
+     COMMAND *command;
+{
+  COMMAND *new_command = (COMMAND *)NULL;
+
+  if (command)
+    {
+      new_command = (COMMAND *)xmalloc (sizeof (COMMAND));
+      FASTCOPY ((char *)command, (char *)new_command, sizeof (COMMAND));
+      new_command->flags = command->flags;
+      new_command->line = command->line;
+
+      if (command->redirects)
+	new_command->redirects = copy_redirects (command->redirects);
+
+      switch (command->type)
+	{
+	case cm_for:
+	  new_command->value.For = copy_for_command (command->value.For);
+	  break;
+
+#if defined (SELECT_COMMAND)
+	case cm_select:
+	  new_command->value.Select = copy_select_command (command->value.Select);
+	  break;
+#endif
+
+	case cm_group:
+	  new_command->value.Group = copy_group_command (command->value.Group);
+	  break;
+
+	case cm_case:
+	  new_command->value.Case = copy_case_command (command->value.Case);
+	  break;
+      
+	case cm_until:
+	case cm_while:
+	  new_command->value.While = copy_while_command (command->value.While);
+	  break;
+      
+	case cm_if:
+	  new_command->value.If = copy_if_command (command->value.If);
+	  break;
+      
+	case cm_simple:
+	  new_command->value.Simple = copy_simple_command (command->value.Simple);
+	  break;
+      
+	case cm_connection:
+	  {
+	    CONNECTION *new_connection;
+
+	    new_connection = (CONNECTION *)xmalloc (sizeof (CONNECTION));
+	    new_connection->connector = command->value.Connection->connector;
+	    new_connection->first =
+	      copy_command (command->value.Connection->first);
+	    new_connection->second =
+	      copy_command (command->value.Connection->second);
+	    new_command->value.Connection = new_connection;
+	    break;
+	  }
+      
+	  /* Pathological case.  I'm not even sure that you can have a
+	     function definition as part of a function definition. */
+	case cm_function_def:
+	  new_command->value.Function_def =
+	    copy_function_def (command->value.Function_def);
+	  break;
+	}
+    }
+  return (new_command);
+}

dispose_cmd.c

@@ -0,0 +1,207 @@
+/* dispose_command.c -- dispose of a COMMAND structure. */
+
+/* Copyright (C) 1987,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 1, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "shell.h"
+
+/* Dispose of the command structure passed. */
+void
+dispose_command (command)
+     COMMAND *command;
+{
+  if (!command) return;
+
+  if (command->redirects)
+    dispose_redirects (command->redirects);
+
+  switch (command->type)
+    {
+    case cm_for:
+      {
+	register FOR_COM *c = command->value.For;
+	dispose_word (c->name);
+	dispose_words (c->map_list);
+	dispose_command (c->action);
+	free (c);
+	break;
+      }
+
+#if defined (SELECT_COMMAND)
+    case cm_select:
+      {
+	register SELECT_COM *c = command->value.Select;
+	dispose_word (c->name);
+	dispose_words (c->map_list);
+	dispose_command (c->action);
+	free (c);
+	break;
+      }
+#endif
+    
+    case cm_group:
+      {
+	dispose_command (command->value.Group->command);
+	free (command->value.Group);
+	break;
+      }
+
+    case cm_case:
+      {
+	register CASE_COM *c = command->value.Case;
+	PATTERN_LIST *t, *p = c->clauses;
+
+	dispose_word (c->word);
+
+	while (p)
+	  {
+	    dispose_words (p->patterns);
+	    dispose_command (p->action);
+	    t = p;
+	    p = p->next;
+	    free (t);
+	  }
+	free (c);
+	break;
+      }
+
+    case cm_until:
+    case cm_while:
+      {
+	register WHILE_COM *c = command->value.While;
+
+	dispose_command (c->test);
+	dispose_command (c->action);
+	free (c);
+	break;
+      }
+
+    case cm_if:
+      {
+	register IF_COM *c = command->value.If;
+	dispose_command (c->test);
+	dispose_command (c->true_case);
+	dispose_command (c->false_case);
+	free (c);
+	break;
+      }
+
+    case cm_simple:
+      {
+	register SIMPLE_COM *c = command->value.Simple;
+	dispose_words (c->words);
+	dispose_redirects (c->redirects);
+	free (c);
+	break;
+      }
+
+    case cm_connection:
+      {
+	register CONNECTION *c = command->value.Connection;
+	dispose_command (c->first);
+	dispose_command (c->second);
+	free (c);
+	break;
+      }
+
+    case cm_function_def:
+      {
+	register FUNCTION_DEF *c = command->value.Function_def;
+	dispose_word (c->name);
+	dispose_command (c->command);
+	free (c);
+	break;
+      }
+
+    default:
+      report_error ("Attempt to free unknown command type `%d'.\n", command->type);
+      break;
+    }
+  free (command);
+}
+
+/* How to free a WORD_DESC. */
+void
+dispose_word (word)
+     WORD_DESC *word;
+{
+  if (word->word)
+    free (word->word);
+  free (word);
+}
+
+/* How to get rid of a linked list of words.  A WORD_LIST. */
+void
+dispose_words (list)
+     WORD_LIST *list;
+{
+  WORD_LIST *t;
+  while (list)
+    {
+      t = list;
+      list = list->next;
+      dispose_word (t->word);
+      free (t);
+    }
+}
+
+/* How to dispose of an array of pointers to char. */
+void
+dispose_word_array (array)
+     char **array;
+{
+  register int count;
+
+  for (count = 0; array[count]; count++)
+    free (array[count]);
+
+  free (array);
+}
+
+/* How to dispose of an list of redirections.  A REDIRECT. */
+void
+dispose_redirects (list)
+     REDIRECT *list;
+{
+  register REDIRECT *t;
+
+  while (list)
+    {
+      t = list;
+      list = list->next;
+      switch (t->instruction)
+	{
+	case r_reading_until:
+	case r_deblank_reading_until:
+	  free (t->here_doc_eof);
+	  /* ... */
+	case r_output_direction:
+	case r_input_direction:
+	case r_inputa_direction:
+	case r_appending_to:
+	case r_err_and_out:
+	case r_input_output:
+	case r_output_force:
+	case r_duplicating_input_word:
+	case r_duplicating_output_word:
+	  dispose_word (t->redirectee.filename);
+	  break;
+	}
+      free (t);
+    }
+}

dispose_cmd.h

@@ -0,0 +1,32 @@
+/* dispose_cmd.h -- Functions appearing in dispose_cmd.c. */
+
+/* Copyright (C) 1993 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#if !defined (_DISPOSE_CMD_H_)
+#define _DISPOSE_CMD_H_
+
+#include "stdc.h"
+
+extern void dispose_command __P((COMMAND *));
+extern void dispose_word __P((WORD_DESC *));
+extern void dispose_words __P((WORD_LIST *));
+extern void dispose_word_array __P((char **));
+extern void dispose_redirects __P((REDIRECT *));
+
+#endif /* !_DISPOSE_CMD_H_ */

documentation/FAQ

@@ -0,0 +1,795 @@
+This is the Bash FAQ, version 1.2, for Bash version 1.14.6.
+
+This document contains a set of frequently-asked questions concerning
+Bash, the GNU Bourne-Again Shell.  Bash is a freely-available command
+interpreter with advanced features for both interactive use and shell
+programming.
+
+Another good source of basic information about shells is the collection
+of FAQ articles periodically posted to comp.unix.shell.
+
+Questions and comments concerning this document should be set to
+chet@po.cwru.edu.
+
+Contents:
+1)  What is it?
+2)  What's the latest version?
+3)  Where can I get it?
+4)  What's the `Posix 1003.2 standard'?
+5)  On what machines will bash run?
+6)  How does bash differ from sh, the Bourne shell?
+7)  How does bash differ from the Korn shell?
+8)  What is the bash `posix mode'?
+9)  How can I build bash with gcc?
+10) Why does bash run a different version of `command' than
+    `which command' says it will?
+11) How can I make my csh aliases work when I convert to bash?
+12) Now that I've converted from ksh to bash, are there equivalents to
+    ksh features like autoloaded functions and the `whence' command?
+13) Why is the bash builtin `test' slightly different from /bin/test?
+14) Why does bash sometimes say `Broken pipe'?
+15) How can I get bash to read and display eight-bit characters?
+16) Why can't I use command line editing in my `cmdtool'?
+17) How do I write a function `x' to replace builtin command `x', but
+    still invoke the command from within the function?
+18) When I have terminal escape sequences in my prompt, why does bash
+    wrap lines at the wrong column?
+19) I built bash on Solaris 2.  Why do globbing expansions and filename
+    completion chop off the first few characters of each filename?
+20) Why doesn't bash treat brace expansions exactly like csh?
+21) Why does bash dump core after I interrupt username completion?
+22) I'm running SVR4.2.  Why is the line erased every time I type `@'?
+23) How can I find the value of a shell variable whose name is the value
+    of another shell variable?
+24) If I pipe the output of a command into `read variable', why doesn't
+    the output show up in $variable when the read command finishes?
+25) I just changed my shell to bash, and now I can't FTP into my machine.
+    Why not?
+26) I have a bunch of shell scripts that use backslash-escaped characters
+    in arguments to `echo'.  Bash doesn't interpret these characters.  Why
+    not, and how can I make it understand them?
+27) Why doesn't bash have csh variable modifiers?
+28) Why does bash report syntax errors when my C News scripts use a
+    redirection before a subshell command?
+29) How do I report bugs in bash, and where should I look for fixes and
+    advice?
+30) What kind of bash documentation is there?
+31) What's coming in future versions?
+32) What's on the bash `wish list'?
+33) When will the next release appear?
+
+1)  What is it?
+
+Bash is a Unix command interpreter (shell).  It is an implementation of
+the Posix 1003.2 shell standard, and resembles the Korn and System V
+shells.
+
+Bash contains a number of enhancements over those shells, both
+for interactive use and shell programming.  Features geared
+toward interactive use include command line editing, command
+history, job control, aliases, and prompt expansion.  Programming
+features include additional variable expansions, shell
+arithmetic, and a number of variables and options to control
+shell behavior.
+
+Bash was originally written by Brian Fox of the Free Software
+Foundation.  The current developer and maintainer is Chet Ramey
+of Case Western Reserve University.
+
+2)  What's the latest version?
+
+The latest version is 1.14.6, first made available on December 19, 1995.
+
+3)  Where can I get it?
+
+Bash is the GNU project's shell, and so is available from the
+master GNU archive site, prep.ai.mit.edu, and its mirrors.  The
+latest version is also available for FTP from slc2.ins.cwru.edu,
+the maintainer's machine.  The following URLs tell how to get
+version 1.14.6:
+
+ftp://prep.ai.mit.edu/pub/gnu/bash-1.14.6.tar.gz
+ftp://slc2.ins.cwru.edu/pub/dist/bash-1.14.6.tar.gz
+
+4)  What's the `Posix 1003.2 standard'?
+
+POSIX is a name originally coined by Richard Stallman for a
+family of open system standards based on UNIX.  There are a
+number of aspects of UNIX under consideration for
+standardization, from the basic system services at the system
+call and C library level to applications and tools to system
+administration and management.  Each area of standardization is
+assigned to a working group in the 1003 series. 
+
+The POSIX Shell and Utilities standard has been developed by IEEE
+Working Group 1003.2 (POSIX.2).  It concentrates on the command
+interpreter interface and utility programs commonly executed from
+the command line or by other programs.  An initial version of the
+standard has been approved and published by the IEEE, and work is
+currently underway to update it. 
+
+Bash is concerned with the aspects of the shell's behavior
+defined by POSIX.2.  The shell command language has of course
+been standardized, including the basic flow control and program
+execution constructs, I/O redirection and pipelining, argument
+handling, variable expansion, and quoting. 
+
+The `special' builtins, which must be implemented as part of the
+shell to provide the desired functionality, are specified as
+being part of the shell; examples of these are `eval' and
+`export'.  Other utilities appear in the sections of POSIX.2 not
+devoted to the shell which are commonly (and in some cases must
+be) implemented as builtin commands, such as `read' and `test'. 
+POSIX.2 also specifies aspects of the shell's interactive
+behavior as part of the UPE, including job control and command
+line editing.  Only vi-style line editing commands have been
+standardized; emacs editing commands were left out due to
+objections.
+
+5)  On what machines will bash run?
+
+Bash has been ported to nearly every version of UNIX.  All you
+should have to do to build it on a machine for which a port
+exists is to type `make'.  The build process will attempt to
+discover the version of UNIX you have and tailor itself
+accordingly, using a combination of saved definitions in the file
+`machines.h' and a file `sysdefs.h' created by inspecting the
+environment for various things. 
+
+More information appears in the file `INSTALL' in the distribution.
+
+6)  How does bash differ from sh, the Bourne shell?
+
+This is a non-comprehensive list of features that differentiate bash
+from the SVR4 shell.  The bash manual page explains these completely.
+
+Things bash has that sh does not:
+	long invocation options
+	`!' reserved word to invert pipeline return value
+	the select compound command
+	the $(...) form of command substitution
+	the ${#param} parameter value length operator
+	expansions to perform substring removal (${p%[%]w}, ${p#[#]w})
+	variables: BASH, BASH_VERSION, UID, EUID, REPLY, PPID, PWD,
+		   OLDPWD, SHLVL, RANDOM, SECONDS, LINENO, HISTCMD,
+		   HOSTTYPE, OSTYPE, ENV, MAIL_WARNING, PS3, PS4,
+		   HISTSIZE, HISTFILE, HISTFILESIZE, PROMPT_COMMAND,
+		   FCEDIT, FIGNORE, IGNOREEOF, INPUTRC, HISTCONTROL,
+		   command_oriented_history, allow_null_glob_expansion,
+		   glob_dot_filenames, histchars, nolinks, auto_resume,
+		   HOSTFILE, noclobber, TMOUT, no_exit_on_failed_exec,
+		   cdable_vars
+	redirections: <>, &>, >|
+	prompt string special char translation and variable expansion
+	auto-export of modified values of variables in initial environment
+	command search finds functions before builtins
+	bash return builtin will exit a file sourced with `.'
+	builtins: cd -, exec -, echo -e/-E, export -n/-f/-p/name=value,
+		  pwd -P, read -r, readonly -f, trap -l, ulimit -n/-p/-u,
+		  set -b/-m/-o option/-p/-l/-d/-C/-H/-P, unset -f/-v,
+		  umask -S, type -all/-path/-type, suspend -f, kill -s
+	bash reads ~/.bashrc for interactive shells, $ENV for non-interactive
+	bash restricted shell mode is more extensive
+	bash allows functions and variables with the same name
+	brace expansion
+	tilde expansion
+	arithmetic expansion and `let' builtin
+	process substitution
+	aliases and alias/unalias builtins
+	local variables in functions and `local' builtin
+	readline and command-line editing
+	history and history/fc builtins
+	csh-like history expansion
+	other new bash builtins: bind, command, builtin, declare/typeset,
+				 dirs, enable, fc, help, history, logout,
+				 popd, pushd
+	exported functions
+	filename generation when using output redirection (command >a*)
+
+Things sh has that bash does not:
+	uses variable SHACCT to do shell accounting
+	includes `stop' builtin (bash can use alias stop='kill -s STOP')
+	`newgrp' builtin
+	turns on job control if called as `jsh'
+	ulimit attempts to set both soft & hard limits if -S/-H not given
+
+New things in the SVR4.2 sh:
+	internationalization: $LANG, $LC_CTYPE, $LC_MESSAGES, setlocale, etc.
+	$TIMEOUT (like bash $TMOUT)
+	new builtins: mldmode, priv
+	`read' builtin has -r
+	cannot trap SIGALRM or SIGCHLD
+	kill -s is present
+
+Implementation differences:
+	redirection to/from compound commands causes sh to create a subshell
+	bash does not allow unbalanced quotes; sh silently inserts them at EOF
+	bash does not mess with signal 11
+	sh sets (euid, egid) to (uid, gid) if -p not supplied and uid < 100
+	bash splits only the results of expansions on IFS
+	sh does not allow MAILCHECK to be unset (?)
+
+7)  How does bash differ from the Korn shell?
+
+Things bash has or uses that ksh does not:
+	long invocation options
+	`!' reserved word
+	posix mode and posix conformance
+	command hashing
+	tilde expansion for assignment statements that look like $PATH
+	process substitution with named pipes if /dev/fd is not available
+	variables: BASH, BASH_VERSION, UID, EUID, SHLVL, HISTCMD, HOSTTYPE,
+		   OSTYPE, MAIL_WARNING, HISTFILESIZE, OPTERR,
+		   PROMPT_COMMAND, IGNOREEOF, FIGNORE, INPUTRC, HISTCONTROL,
+		   notify, command_oriented_history, glob_dot_filenames,
+		   allow_null_glob_expansion, histchars, nolinks, HOSTFILE,
+		   noclobber, auto_resume, no_exit_on_failed_exec, cdable_vars
+	prompt expansion with backslash escapes and command substitution
+	redirection: &> (stdout and stderr)
+	more extensive and extensible editing and completion
+	builtins: bind, builtin, command, declare, dirs, echo -e/-E, enable,
+		  exec -, fc -s, export -n/-f/-p, hash, help, history,
+		  jobs -x, kill -s, local, logout, popd, pushd,
+		  readonly -n/-f/-p, set -o braceexpand/-o histexpand/
+		  -o interactive-comments/-o notify/-o physical/-o posix/
+		  -l/-d/-C/-b/-H/-P, suspend, trap -l, type, ulimit -u,
+		  umask -S
+	$[...] synonym for $((...))
+	`!' csh-style history expansion
+
+Things ksh has or uses that bash does not:
+	new version of test: [[...]]
+	((...)) equivalent to let "..."
+	time keyword to let pipelines be timed
+	tracked aliases
+	$(<file)	
+	one-dimensional arrays and appropriate expansions
+	variables: ERRNO, FPATH, COLUMNS, LINES, EDITOR, VISUAL
+	extended pattern matching with egrep-style pattern lists
+	co-processes (|&, >&p, <&p)
+	weirdly-scoped functions
+	typeset +f to list all function names without definitions
+	text of command history kept in a file, not memory
+	builtins: alias -x, cd old new, fc -e -, newgrp, print,
+		  read -p/-s/u/var?prompt, set -A/-o gmacs/-o keyword/
+		  -o bgnice/-o markdirs/-o nolog/-o trackall/-o viraw/-s,
+		  typeset -H/-L/-R/-A/-ft/-fu/-fx/-l/-u/-t, whence
+
+Implementation differences:
+	ksh runs last command of a pipeline in parent shell context
+	ksh ulimit sets hard and soft limits by default
+	bash has brace expansion by default
+	bash has fixed startup file for all interactive shells; ksh reads $ENV
+	bash has exported functions
+	bash command search finds functions before builtins
+
+8)  What is the bash `posix mode'?
+
+Although bash is an implementation of the Posix.2 shell
+specification, there are areas where the bash default behavior
+differs from that spec.  The bash `posix mode' changes the bash
+behavior in these areas so that it obeys the spec more closely. 
+
+Posix mode is entered by starting bash with the -posix option or
+executing `set -o posix' after bash is running.
+
+The specific aspects of bash which change when posix mode is
+active are listed in the file CWRU/POSIX.NOTES in the bash
+distribution. 
+
+9) How can I build bash with gcc? 
+
+Type
+	make CC=gcc CPPNAME='$(CC) -E'
+
+10) Why does bash run a different version of `command' than
+    `which command' says it will?
+
+`which' is actually a csh script that assumes you're running csh. 
+It reads the csh startup files from your home directory and uses
+those to determine which `command' will be invoked.  Since bash
+doesn't use any of those startup files, there's a good chance
+that your bash environment differs from your csh environment. 
+
+11) How can I make my csh aliases work when I convert to bash?
+
+Bash uses a different syntax to support aliases than csh does. 
+The details can be found in the documentation.  We have provided
+a shell script which does most of the work of conversion for you;
+this script can be found in ./examples/alias-conv.sh.  Here is
+how you use it:
+  
+Start csh in the normal way for you.  (e.g., `csh')
+  
+Pipe the output of `alias' through `alias-conv.sh', saving the
+results into `bash_aliases':
+  
+	alias | alias-conv.sh >bash_aliases
+  
+Edit `bash_aliases', carefully reading through any created
+functions.  You will need to change the names of csh specific
+variables (like $cwd) to the bash equivalents (like $PWD).  You
+will also need to remove recursive references to commands which
+are defined as functions.  For example, the csh alias:
+  
+	alias cd 'cd \!*;echo $cwd'
+  
+is converted to the bash function:
+
+	cd () 
+	{ 
+		cd $*;
+		echo $cwd
+	}
+  
+This function contains a self-pointing reference to `cd', which
+should be changed to use the `builtin' version.  It also uses
+the csh variable `$cwd' which has an equivalent in bash.
+Precede the recursive reference with the word `builtin', and
+change the name of the variable:
+  
+        cd () { builtin cd $*; echo $PWD; }
+  
+Merge the edited file into your ~/.bashrc.
+
+12) Now that I've converted from ksh to bash, are there equivalents to
+    ksh features like autoloaded functions and the `whence' command?
+
+There are features in ksh-88 that do not have direct bash equivalents.
+Most, however, can be emulated with very little trouble.
+
+ksh-88 feature		Bash equivalent
+--------------		---------------
+[[...]]			can usually use [...]; minor differences
+compiled-in aliases	set up aliases in .bashrc; some ksh aliases are
+			bash builtins (hash, history, type)
+$(<file)		$(cat file)
+arrays			no good subsitute yet
+((...))			let "..."
+time			use external command; GNU time is particularly useful
+			use time bash -c '...' for complicated constructs
+extended patterns	no good substitute
+coprocesses		named pipe pairs (one for read, one for write)
+typeset +f		declare -f |
+			     sed -n 's:^declare -[a-z]* \([^ ]*\).*$:\1:p'
+cd, print, whence	function subsitutes in examples/functions/kshenv
+autoloaded functions	examples/functions/autoload is the same as typeset -fu
+read var?prompt		[ -t 0 ] && echo -n prompt >&2; read var
+
+13) Why is the bash builtin `test' slightly different from /bin/test?
+
+The specific example used here is [ ! x -o x ], which is false.
+
+Bash's builtin `test' implements the Posix.2 spec, which can be
+summarized as follows (the wording is due to David Korn):
+   
+Here is the set of rules for processing test arguments.
+  
+    0 Args: False
+    1 Arg:  True iff argument is not null.
+    2 Args: If first arg is !, True iff second argument is null.
+	    If first argument is unary, then true if unary test is true
+	    Otherwise error.
+    3 Args: If second argument is a binary operator, do binary test of $1 $3
+	    If first argument is !, negate two argument test of $2 $3
+	    Otherwise error.
+    4 Args: If first argument is !, negate three argument test of $2 $3 $4.
+	    Otherwise unspecified
+    5 or more Args: unspecified.  (Historical shells would use their
+    current algorithm).
+   
+The operators -a and -o are considered binary operators for the purpose
+of the 3 Arg case.
+   
+As you can see, the test becomes (not (x or x)), which is false.
+
+14) Why does bash sometimes say `Broken pipe'?
+
+If a sequence of commands appear in a pipeline, and one of the
+reading commands finishes before the writer has finished, the
+writer receives a SIGPIPE signal.  Many other shells special-case
+SIGPIPE as an exit status in the pipeline and do not report it. 
+For example, in:
+  
+      ps -aux | head
+  
+`head' can finish before `ps' writes all of its output, and ps
+will try to write on a pipe without a reader.  In that case, bash
+will print `Broken pipe' to stderr when ps is killed by a
+SIGPIPE. 
+
+15) How can I get bash to read and display eight-bit characters?
+
+This is a process requiring several steps.
+
+First, you must ensure that the `physical' data path is a full eight
+bits.  For xterms, for example, the `vt100' resources `eightBitInput'
+and `eightBitOutput' should be set to `true'.
+
+Once you have set up an eight-bit path, you must tell the kernel and
+tty driver to leave the eigth bit of characters alone when processing
+keyboard input.  Use `stty' to do this:
+
+	stty cs8 -istrip -parenb
+
+For old BSD-style systems, you can use
+
+	stty pass8
+
+You may also need
+
+	stty even odd
+
+Finally, you need to tell readline that you will be inputting and
+displaying eight-bit characters.  You use readline variables to do
+this.  These variables can be set in your .inputrc or using the bash
+`bind' builtin.  Here's an example using `bind':
+
+	bash$ bind 'set convert-meta off'
+	bash$ bind 'set meta-flag on'
+	bash$ bind 'set output-meta on'
+
+The `set' commands between the single quotes may also be placed
+in ~/.inputrc.
+
+16) Why can't I use command line editing in my `cmdtool'?
+
+The problem is `cmdtool' and bash fighting over the input.  When
+scrolling is enabled in a cmdtool window, cmdtool puts the tty in
+`raw mode' to permit command-line editing using the mouse for
+applications that cannot do it themselves.  As a result, bash and
+cmdtool each try to read keyboard input immediately, with neither
+getting enough of it to be useful.
+
+This mode also causes cmdtool to not implement many of the
+terminal functions and control sequences appearing in the
+`sun-cmd' termcap entry.  For a more complete explanation, see
+that file examples/suncmd.termcap in the bash distribution. 
+
+`xterm' is a better choice, and gets along with bash much more
+smoothly.
+
+17) How do I write a function `x' to replace builtin command `x', but
+    still invoke the command from within the function?
+
+This is what the `command' and `builtin' builtins are for.  The
+`command' builtin executes the command supplied as its first
+argument, skipping over any function defined with that name.  The
+`builtin' builtin executes the builtin command given as its first
+argument directly. 
+
+For example, to write a function to replace `cd' that writes the
+hostname and current directory to an xterm title bar, use
+something like the following:
+
+	cd()
+	{
+		builtin cd "$@" && xtitle $HOST: $PWD
+	}
+
+This could also be written using `command' instead of `builtin';
+the version above is marginally more efficient. 
+
+18) When I have terminal escape sequences in my prompt, why does bash
+    wrap lines at the wrong column?
+
+Bash does not know that the terminal escape sequences do not take
+up space on the screen.  The redisplay code assumes, unless told
+otherwise, that each character in the prompt is a `printable'
+character that takes up one character position on the screen. 
+
+You can use the bash prompt expansion facility (see the PROMPTING
+section in the manual page) to tell readline that sequences of
+characters in the prompt strings take up no screen space. 
+
+Use the \[ escape to begin a sequence of non-printing characters,
+and the \] escape to signal the end of such a sequence. 
+
+19) I built bash on Solaris 2.  Why do globbing expansions and filename
+    completion chop off the first few characters of each filename?
+
+This is the consequence of building bash on SunOS 5 and linking
+with the libraries in /usr/ucblib, but using the definitions
+and strutures from files in /usr/include. 
+
+The actual conflict is between the dirent structure in
+/usr/include/dirent.h and the struct returned by the version of
+`readdir' in libucb.a (a 4.3-BSD style `struct direct'). 
+
+Make sure you've got /usr/ccs/bin ahead of /usr/ucb in your $PATH
+when building bash.  This will ensure that you use /usr/ccs/bin/cc
+or acc instead of /usr/ucb/cc and that you link with libc before
+libucb.
+
+If you have installed the Sun C compiler, you may also need to
+put /usr/ccs/bin and /opt/SUNWspro/bin into your $PATH before
+/usr/ucb.
+
+20) Why doesn't bash treat brace expansions exactly like csh?
+
+The only difference between bash and csh brace expansion is that
+bash requires a brace expression to contain at least on unquoted
+comma if it is to be expanded.  Any brace-surrounded word not
+containing an unquoted comma is left unchanged by the brace
+expansion code.  This affords the greatest degree of sh
+compatibility. 
+
+Bash, ksh, zsh, and pd-ksh all implement brace expansion this way. 
+
+21) Why does bash dump core after I interrupt username completion on a
+    machine running NIS?
+
+This is a famous and long-standing bug in the SunOS YP (sorry, NIS)
+client library, which is part of libc.
+
+The YP library code keeps static state -- a pointer into the data
+returned from the server.  When YP initializes itself (setpwent),
+it looks at this pointer and calls free on it if it's non-null. 
+So far, so good. 
+
+If one of the YP functions is interrupted during getpwent (the
+exact function is interpretwithsave()), and returns NULL, the
+pointer is freed without being reset to NULL, and the function
+returns.  The next time getpwent is called, it sees that this
+pointer is non-null, calls free, and the bash free() blows up
+because it's being asked to free freed memory. 
+
+The traditional Unix mallocs allow memory to be freed multiple
+times; that's probably why this has never been fixed.  You can
+probably stop it by adding an #undef USE_GNU_MALLOC to the
+appropriate machine description in machines.h. 
+
+22) I'm running SVR4.2.  Why is the line erased every time I type `@'?
+
+The `@' character is the default `line kill' character in most
+versions of System V, including SVR4.2.  You can change this
+character to whatever you want using `stty'.  For example, to
+change the line kill character to control-u, type
+
+	stty kill ^U
+
+where the `^' and `U' can be two separate characters.
+
+23) How can I find the value of a shell variable whose name is the value
+    of another shell variable?
+
+Use the `eval' builtin.  The important thing to remember is that
+`eval' expands the arguments you give it again, so you need to
+quote the parts of the arguments that you want `eval' to act on. 
+
+For example, this expression prints the value of the last positional
+parameter:
+
+	eval echo \$\{$#\}
+
+The expansion of the quoted portions of this expression will be
+deferred until `eval' runs, while the `$#' will be expanded
+before `eval' is executed. 
+
+24) If I pipe the output of a command into `read variable', why doesn't
+    the output show up in $variable when the read command finishes?
+
+This has to do with the parent-child relationship between Unix
+processes. 
+
+Each element of a pipeline runs in a separate process, a child of
+the shell running the pipeline.  A subprocess cannot affect its
+parent's environment.  When the `read' command sets the variable
+to the input, that variable is set only in the subshell, not the
+parent shell.  When the subshell exits, the value of the variable
+is lost. 
+
+Many pipelines that end with `read variable' can be converted
+into command substitutions, which will capture the output into a
+variable:
+
+	grep ^gnu /usr/lib/news/active | wc -l | read ngroup
+
+can be converted into
+
+	ngroup=$(grep ^gnu /usr/lib/news/active | wc -l)
+
+This does not, unfortunately, work to split the text among
+multiple variables, as read does when given multiple variable
+arguments.
+
+25) I just changed my shell to bash, and now I can't FTP into my machine.
+    Why not?
+
+You must add the full pathname to bash to the file /etc/shells. 
+Many versions of ftpd use this file to prohibit `special' users
+such as `uucp' and `news' from using FTP. 
+
+26) I have a bunch of shell scripts that use backslash-escaped characters
+    in arguments to `echo'.  Bash doesn't interpret these characters.  Why
+    not, and how can I make it understand them?
+
+This is the behavior of echo on most Unix System V machines.
+
+The bash builtin `echo' is modelled after the 9th Edition
+Research Unix version of `echo'.  It does not interpret
+backslash-escaped characters in its argument strings by default,
+but requires the use of the -e option to enable the
+interpretation.  The System V echo provides no way to disable the
+special characters; the bash echo has a -E option to disable
+them. 
+
+There is a compile-time option that will make bash behave like
+the System V echo and interpret things like \t by default. 
+Change config.h so that DEFAULT_ECHO_TO_USG is defined, remove
+builtins/libbuiltins.a and builtins/echo.o, and rebuild.
+
+27) Why doesn't bash have csh variable modifiers?
+
+Posix has specified a more powerful, albeit somewhat more confusing,
+mechanism cribbed from ksh, and bash implements it.
+
+${parameter%word}
+        Remove smallest suffix pattern.  The WORD is expanded to produce
+        a pattern.  It then expands to the value of PARAMETER, with the
+        smallest portion of the suffix matched by the pattern deleted.
+
+        x=file.c
+        echo ${x%.c}.o
+        -->file.o
+
+${parameter%%word}
+
+        Remove largest suffix pattern.  The WORD is expanded to produce
+        a pattern.  It then expands to the value of PARAMETER, with the
+        largest portion of the suffix matched by the pattern deleted.
+
+        x=posix/src/std
+        echo ${x%%/*}
+        -->posix
+
+${parameter#word}
+        Remove smallest prefix pattern.  The WORD is expanded to produce
+        a pattern.  It then expands to the value of PARAMETER, with the
+        smallest portion of the prefix matched by the pattern deleted.
+
+        x=$HOME/src/cmd
+        echo ${x#$HOME}
+        -->/src/cmd
+
+${parameter##word}
+        Remove largest prefix pattern.  The WORD is expanded to produce
+        a pattern.  It then expands to the value of PARAMETER, with the
+        largest portion of the prefix matched by the pattern deleted.
+
+        x=/one/two/three
+        echo ${x##*/}
+        -->three
+
+
+Given
+	a=/a/b/c/d
+	b=b.xxx
+
+	csh			bash		result
+	---			----		------
+	$a:h			${a%/*}		   /a/b/c
+	$a:t			${a##*/}	   d
+	$b:r			${b%.*}		   b
+	$b:e			${b##*.}	   xxx
+
+
+28) Why does bash report syntax errors when my C News scripts use a
+    redirection before a subshell command?
+
+The actual command in question is something like
+
+	< file ( command )
+
+According to the grammar given in the Posix.2 standard, this construct
+is, in fact, a syntax error.  Redirections may only precede `simple
+commands'.  A subshell construct such as the above is one of the shell's
+`compound commands'.  A redirection may only follow a compound command.
+
+The file CWRU/sh-redir-hack in the 1.14.6 distribution is an (unofficial)
+patch to parse.y that will modify the grammar to support this construct.
+Note that if you apply this, you must recompile with -DREDIRECTION_HACK.
+This introduces a large number of reduce/reduce conflicts into the shell
+grammar.
+
+29) How do I report bugs in bash, and where should I look for fixes and
+    advice?
+
+Use the `bashbug' script to report bugs.  It is built and
+installed at the same time as bash.  It provides a standard
+template for reporting a problem and automatically includes
+information about your configuration and build environment. 
+
+`bashbug' sends its reports to bug-bash@prep.ai.mit.edu, which
+is a large mailing list gatewayed to the usenet newsgroup gnu.bash.bug. 
+
+Bug fixes, answers to questions, and announcements of new releases
+are all posted to gnu.bash.bug.  Discussions concerning bash features
+and problems also take place there.
+
+To reach the bash maintainers directly, send mail to
+bash-maintainers@prep.ai.mit.edu.
+
+30) What kind of bash documentation is there?
+
+First, look in the documentation directory in the bash distribution.
+It should contain the following files:
+
+bash.1		an extensive, thorough Unix-style manual page
+builtins.1	a manual page covering just bash builtin commands
+features.texi	a Gnu-style info file overview
+FAQ		this file
+article.ms	text of an article written for The Linux Journal
+readline.3	a man page describing readline
+
+Postscript files created from the above source are also present in
+the distribution.
+
+There is additional documentation available for anonymous FTP from host
+slc2.ins.cwru.edu in the `pub/bash' directory.
+
+Cameron Newham is in the midst of writing a book on bash, to be
+published by O'Reilly and Associates.  Look for it sometime this
+year.
+
+31) What's coming in future versions?
+
+There will be no new features in future releases of version 1.14.
+
+The next major release, bash-2.0, will contain extensive changes and new
+features.  Here's a short list:
+
+one-dimensional arrays with a new compound assignment statement,
+        appropriate expansion constructs and modifications to some
+	of the builtins (read, declare, etc.) to use them
+new expansions to do ANSI-C string expansion, substring extraction,
+	pattern replacement, and indirect variable expansion
+new builtins: `disown' and `shopt'
+new variables: HISTIGNORE, SHELLOPTS, PIPESTATUS, DIRSTACK
+special handling of many unused or redundant variables removed
+dynamic loading of new builtin commands; many loadable examples provided
+new prompt expansions: \e, \n, \H, \T
+new readline variables: enable-keypad, mark-directories, input-meta
+new readline commands to manipulate the mark and operate on the region
+new readline emacs mode commands and bindings for ksh-88 compatibility
+updated and extended builtins
+new DEBUG trap
+expanded (and now documented) restricted shell mode
+
+implementation stuff:	
+autoconf-based configuration
+nearly all of the bugs reported since version 1.14 have been fixed
+most builtins converted to use builtin `getopt' for consistency
+most builtins use -p option to display output in a reusable form
+	(for consistency)
+grammar tighter and smaller (66 reduce-reduce conflicts gone)
+lots of code now smaller and faster
+test suite greatly expanded
+
+32) What's on the bash `wish list'?
+
+internationalization with a variable expansion to translate a string
+	according to a particular message catalog
+Programmable completion a la zsh
+menu completion a la tcsh
+the ksh egrep-style extended pattern matching operators
+associative arrays (not really all that hard)
+breaking some of the shell functionality into embeddable libraries
+a bash debugger
+
+Much of this will not be in bash-2.0.
+
+33) When will the next release appear?
+
+Version 1.14.6 will probably be the last release for version 1.14.
+
+The next version will appear sometime in 1996.  Never make predictions.
+
+
+This document is copyright Chester Ramey, 1995.
+
+Permission is hereby granted, without written agreement and
+without license or royalty fees, to use, copy, and distribute
+this document for any purpose, provided that the above copyright
+notice appears in all copies of this document and that the
+contents of this document remain unaltered.

documentation/Makefile

@@ -0,0 +1,103 @@
+# This Makefile is for the Bash/documentation directory -*- text -*-.
+#
+RM	    = rm -f
+
+INSTALL_DATA = ../support/install.sh -c -m 644
+
+# unused
+TEXINDEX    = texindex
+TEX	    = tex
+
+MAKEINFO    = makeinfo
+TEXI2DVI    = ../support/texi2dvi
+QUIETPS	    = #set this to -q to shut up dvips
+DVIPS	    = dvips -D 300 $(QUIETPS) -o $@	# tricky
+TEXINPUTS   = ./../lib/readline/doc
+
+# Change to groff -Tascii if you don't have nroff
+NROFF	    = nroff
+
+# This should be a program that converts troff to postscript
+GROFF	    = groff
+
+HSUSER      = ./../lib/readline/doc/hsuser.texinfo
+RLUSER      = ./../lib/readline/doc/rluser.texinfo
+
+.SUFFIXES:	.1 .3 .ms .ps .txt .dvi
+
+.1.ps:
+	$(RM) $@
+	${GROFF} -man $< > $@
+
+.1.txt:
+	$(RM) $@
+	${NROFF} -man $< > $@
+
+.ms.ps:
+	$(RM) $@
+	${GROFF} -ms $< > $@
+
+.ms.txt:
+	$(RM) $@
+	${NROFF} -ms $< > $@
+
+.3.ps:
+	$(RM) $@
+	${GROFF} -man $< > $@
+
+.3.txt:
+	$(RM) $@
+	${NROFF} -man $< > $@
+
+all: ps info dvi text
+
+ps: bash.ps readline.ps article.ps
+dvi: features.dvi features.ps 
+info: features.info
+text: bash.txt builtins.txt readline.txt article.txt
+
+features.dvi: features.texi $(HSUSER) $(RLUSER)
+	TEXINPUTS=.:$(TEXINPUTS):$$TEXINPUTS $(TEXI2DVI) features.texi
+
+features.ps: features.dvi
+	$(RM) $@
+	$(DVIPS) features.dvi
+
+features.info: features.texi $(HSUSER) $(RLUSER)
+	$(MAKEINFO) --no-split -I$(TEXINPUTS) features.texi
+
+bash.txt: bash.1
+bash.ps: bash.1
+builtins.txt: builtins.1 bash.1
+readline.txt: readline.3
+readline.ps: readline.3
+article.ps: article.ms
+
+hsuser.texinfo: ../lib/readline/doc/hsuser.texinfo
+	ln -s ../lib/readline/doc/hsuser.texinfo .
+
+rluser.texinfo: ../lib/readline/doc/rluser.texinfo
+	ln -s ../lib/readline/doc/rluser.texinfo .
+
+clean:
+	$(RM) *.aux *.cp *.fn *.ky *.log *.pg *.toc *.tp *.vr *.cps *.pgs \
+	*.fns *.kys *.tps *.vrs *.o core rluser.texinfo hsuser.texinfo
+
+distclean mostlyclean:	clean
+
+realclean maintainer-clean:	clean
+	rm -f *.dvi *.info *.ps *.txt
+
+installdirs:
+	-[ -d $(mandir) ] || mkdir $(mandir)
+	-[ -d $(man3dir) ] || mkdir $(man3dir)
+	-[ -d $(infodir) ] || mkdir $(infodir)
+
+install: all installdirs
+	$(INSTALL_DATA) bash.1 $(mandir)
+	$(INSTALL_DATA) readline.3 $(man3dir)
+	$(INSTALL_DATA) features.info $(infodir)/bash.info
+
+uninstall:
+	$(RM) $(mandir)/bash.1
+	$(RM) $(man3dir)/readline.3 $(infodir)/bash.info

documentation/README

@@ -0,0 +1,32 @@
+This directory contains the bash documentation.
+
+FAQ		- a set of frequently-asked questions about Bash with answers
+article.ms	- an article I wrote about bash for The Linux Journal
+bash.1		- the bash man page
+builtins.1	- a man page that documents the builtins, extracted from bash.1
+features.texi	- the `bash features' document, suitable for an info tree
+readline.3	- the readline man page
+
+The `.ps' files are postscript versions of the above.  The `.txt' versions
+are ascii -- the output of `nroff'.
+
+The rest of this file explains how to use the `builtins.1' man page.
+
+For each command in the list of builtins create a file in man/man1 called:
+
+${command}.1
+
+eg.
+for.1
+type.1
+alias.1
+etc.
+
+All these files are identical as follows:
+
+jaws@jaws(264)$ cat alias.1
+.so man1/builtins.1
+jaws@jaws(265)$ 
+
+Make sure you adjust the .so line in builtins.1 to reflect where you
+put it.

documentation/builtins.1

@@ -0,0 +1,15 @@
+.\" This is a hack to force bash builtins into the whatis database
+.\" and to get the list of builtins to come up with the man command.
+.TH BASH_BUILTINS 1 "1993 September 16" GNU
+.SH NAME
+bash, :, ., alias, bg, bind, break, builtin, bye, case, cd, command,
+continue, declare, dirs, echo, enable, eval, exec, exit, export, fc,
+fg, for, getopts, hash, help, history, if, jobs, kill, let, local,
+logout, popd, pushd, pwd, read, readonly, return, set, shift, source,
+suspend, test, times, trap, type, typeset, ulimit, umask, unalias,
+unset, until, wait, while \- bash built-in commands, see \fBbash\fR(1)
+.SH BASH BUILTIN COMMANDS
+.nr zZ 1
+.so bash.1
+.SH SEE ALSO
+bash(1), sh(1)