


      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



      NNNNAAAAMMMMEEEE
           csh - a shell (command interpreter) with C-like syntax

      SSSSYYYYNNNNTTTTAAAAXXXX
           ccccsssshhhh [ ----cccceeeeffffiiiinnnnssssttttvvvvVVVVxxxxXXXX ] [ arg ...  ]

      DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
           _C_s_h is a first implementation of a command language
           interpreter incorporating a history mechanism (see HHHHiiiissssttttoooorrrryyyy
           SSSSuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnnssss)))) job control facilities (see JJJJoooobbbbssss)))) and a C-
           like syntax.

           An instance of _c_s_h begins by executing commands from the
           file `.cshrc' in the _h_o_m_e directory of the invoker.  If this
           is a login shell then it also executes commands from the
           file `.login' there.  It is typical for users on crt's to
           set terminal options by putting a _s_t_t_y(1) command ``stty
           crt'' in their ._l_o_g_i_n file.

           In the normal case, the shell will then begin reading
           commands from the terminal, prompting with `% '.  Processing
           of arguments and the use of the shell to process files
           containing command scripts will be described later.

           The shell then repeatedly performs the following actions:  a
           line of command input is read and broken into _w_o_r_d_s.  This
           sequence of words is placed on the command history list and
           then parsed.  Finally each command in the current line is
           executed.

           When a login shell terminates, it executes commands from the
           file `.logout' in the users home directory.

           LLLLeeeexxxxiiiiccccaaaallll ssssttttrrrruuuuccccttttuuuurrrreeee

           The shell splits input lines into words at blanks and tabs
           with the following exceptions.  The characters `&' `|' `;'
           `<' `>' `(' `)' form separate words.  If doubled in `&&',
           `||', `<<' or `>>' these pairs form single words.  These
           parser metacharacters may be made part of other words, or
           their special meaning can be suppressed by preceding them
           with `\'.  A newline preceded by a `\' is equivalent to a
           blank.

           In addition, strings enclosed in matched pairs of
           quotations, `'', ``' or `"', form parts of a word;
           metacharacters in these strings, including blanks and tabs,
           do not form separate words.  These quotations have semantics
           to be described subsequently.  Within pairs of `'' or `"'
           characters a newline preceded by a `\' gives a true newline
           character.




      Page 1                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           When the shell's input is not a terminal, the character `#'
           introduces a comment which continues to the end of the input
           line.  The special meaning of the '#' character is
           suppressed when preceded by `\' and in quotations using ``',
           `'', and `"'.

           CCCCoooommmmmmmmaaaannnnddddssss

           A simple command is a sequence of words, the first of which
           specifies the command to be executed.  A simple command or a
           sequence of simple commands separated by `|' characters
           forms a pipeline.  The output of each command in a pipeline
           is connected to the input of the next.  Sequences of
           pipelines may be separated by `;' and are then executed
           sequentially.  A sequence of pipelines may be executed
           without immediately waiting for it to terminate by following
           it with an `&'.

           Any of the above may be placed in `(' `)' to form a simple
           command (which may be a component of a pipeline, etc.).  It
           is also possible to separate pipelines with `||' or `&&'
           indicating, as in the C language, that the second is to be
           executed only if the first fails or succeeds respectively.
           (See _E_x_p_r_e_s_s_i_o_n_s.)

           JJJJoooobbbbssss

           The shell associates a _j_o_b with each pipeline.  It keeps a
           table of current jobs, printed by the _j_o_b_s command, and
           assigns them small integer numbers.  When a job is started
           asynchronously with `&', the shell prints a line which looks
           like:

                [1] 1234

           indicating that the job which was started asynchronously was
           job number 1 and had one (top-level) process, whose process
           id was 1234.

           If you are running a job and wish to do something else, you
           may hit the key ^^^^ZZZZ (control-Z) which sends a STOP signal to
           the current job.  The shell will then normally indicate that
           the job has been `Stopped', and print another prompt.  You
           can then manipulate the state of this job, putting it in the
           background with the _b_g command, or run some other commands
           and then eventually bring the job back into the foreground
           with the foreground command _f_g.  A ^^^^ZZZZ takes effect
           immediately and is like an interrupt in that pending output
           and unread input are discarded when it is typed.  Another
           special key is ^^^^YYYY, which does not generate a STOP signal
           until a program attempts to _r_e_a_d(2) it.  The ^^^^YYYY key is
           useful when you have prepared some commands for a job which



      Page 2                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           you wish to stop after it has read them.

           A job being run in the background will stop if it tries to
           read from the terminal.  Background jobs are normally
           allowed to produce output, but this can be disabled by
           giving the command ``stty tostop''.  If you set this tty
           option, then background jobs will stop when they try to
           produce output.

           There are several ways to refer to jobs in the shell.  The
           character `%' introduces a job name.  If you wish to refer
           to job number 1, you can name it as `%1'.  Just naming a job
           brings it to the foreground; thus `%1' is a synonym for `fg
           %1', which brings job 1 back into the foreground.  Similarly
           `%1 &' returns job 1 to the background.  Jobs can also be
           named by prefixes of the string typed in to start them, if
           these prefixes are unambiguous.  Thus `%ex' would normally
           restart a suspended _e_x(1) job, if there were only one
           suspended job whose name began with the string `ex'.  It is
           also possible to say `%?string' which specifies a job whose
           text contains _s_t_r_i_n_g, if there is only one such job.

           The shell maintains a notion of the current and previous
           jobs.  In output pertaining to jobs, the current job is
           marked with a `+' and the previous job with a `-'.  The
           abbreviation `%+' refers to the current job and `%-' refers
           to the previous job.  For close analogy with the syntax of
           the _h_i_s_t_o_r_y mechanism (described below), `%%' is also a
           synonym for the current job.

           SSSSttttaaaattttuuuussss rrrreeeeppppoooorrrrttttiiiinnnngggg

           This shell learns immediately whenever a process changes
           state.  It normally informs you whenever a job becomes
           blocked so that no further progress is possible, but only
           just before it prints a prompt.  This is done so that it
           does not otherwise disturb your work.  If, however, you set
           the shell variable _n_o_t_i_f_y, the shell will notify you
           immediately of changes of status in background jobs.  There
           is also a shell command _n_o_t_i_f_y which marks a single process
           so that any change in its status will be immediately
           reported.  By default, _n_o_t_i_f_y marks the current process;
           simply say `notify' after starting a background job to mark
           it.

           When you try to leave the shell while jobs are stopped, you
           will be warned that `You have stopped jobs.'  You may use
           the _j_o_b_s command to see what they are.  If you do this or
           immediately try to exit again, the shell will not warn you a
           second time, and the suspended jobs will be terminated.





      Page 3                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           SSSSuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnnssss

           We now describe the various transformations the shell
           performs on the input in the order in which they occur.

           HHHHiiiissssttttoooorrrryyyy ssssuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnnssss

           History substitutions place words from previous command
           input as portions of new commands, making it easy to repeat
           commands, repeat arguments of a previous command in the
           current command, or fix spelling mistakes in the previous
           command with little typing and a high degree of confidence.
           History substitutions begin with the character `!' and may
           begin aaaannnnyyyywwwwhhhheeeerrrreeee in the input stream (with the proviso that
           they ddddoooo nnnnooootttt nest.) This `!' may be preceded by an `\' to
           prevent its special meaning. For convenience, a `!' is
           passed unchanged when it is followed by a blank, tab,
           newline, `=' or `('.  (History substitutions also occur when
           an input line begins with `^|'.  This special abbreviation
           will be described later.) Any input line which contains
           history substitution is echoed on the terminal before it is
           executed.

           Commands input from the terminal which consist of one or
           more words are saved on the history list.  The history
           substitutions reintroduce sequences of words from these
           saved commands into the input stream.  The size of which is
           controlled by the _h_i_s_t_o_r_y variable; the previous command is
           always retained, regardless of its value.  Commands are
           numbered sequentially from 1.

           For example, consider the following output from the _h_i_s_t_o_r_y
           command:

                 9  write michael
                10  ex write.c
                11  cat oldwrite.c
                12  diff *write.c

           The commands are shown with their event numbers.  It is not
           usually necessary to use event numbers, but the current
           event number can be made part of the _p_r_o_m_p_t by placing an
           `!' in the prompt string.

           The current event is number 13.  We can refer to previous
           events by event number.  For example, `!11' refers to the
           same event as `!-2'.  You can also refer to previous events
           by the prefix of a command word, as in `!d' for event 12 or
           `!wri' for event 9, or by a string contained in a word in
           the command as in `!?mic?' also referring to event 9.  These
           forms, without further modification, simply reintroduce the
           words of the specified events, each separated by a single



      Page 4                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           blank.  As a special case `!!' refers to the previous
           command; thus `!!' alone is essentially a _r_e_d_o.

           To select words from an event, we can follow the event
           specification by a `:' and a designator for the desired
           words.  The words of a input line are numbered from 0, the
           first (usually command) word being 0, the second word (first
           argument) being 1, etc.  The basic word designators are:

                0    first (command) word
                _n    _n'th argument
                ^|    first argument,  i.e. `1'
                $    last argument
                %    word matched by (immediately preceding) ?_s? search
                _x-_y  range of words
                -_y   abbreviates `0-_y'
                *    abbreviates `^|-$', or nothing if only 1 word in event
                _x*   abbreviates `_x-$'
                _x-   like `_x*' but omitting word `$'

           The `:' separating the event specification from the word
           designator can be omitted if the argument selector begins
           with a `^|', `$', `*' `-' or `%'.  After the optional word
           designator can be placed a sequence of modifiers, each
           preceded by a `:'.  The following modifiers are defined:

                h      Remove a trailing pathname component, leaving the head.
                r      Remove a trailing `.xxx' component, leaving the root name.
                e      Remove all but the extension `.xxx' part.
                s/_l/_r/ Substitute _l for _r
                t      Remove all leading pathname components, leaving the tail.
                &      Repeat the previous substitution.
                g      Apply the change globally, prefixing the above, e.g. `g&'.
                p      Print the new command but do not execute it.
                q      Quote the substituted words, preventing further substitutions.
                x      Like q, but break into words at blanks, tabs and newlines.

           Unless preceded by a `g' the modification is applied only to
           the first modifiable word.  With substitutions, it is an
           error for no word to be applicable.

           The left hand side of substitutions are not regular
           expressions in the sense of the editors, but rather strings.
           Any character may be used as the delimiter in place of `/';
           a `\' quotes the delimiter into the _l and _r strings.  The
           character `&' in the right hand side is replaced by the text
           from the left.  A `\' quotes `&' also.  A null _l uses the
           previous string either from a _l or from a contextual scan
           string _s in `!?_s?'.  The trailing delimiter in the
           substitution may be omitted if a newline follows immediately
           as may the trailing `?' in a contextual scan.




      Page 5                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           A history reference may be given without an event
           specification, e.g. `!$'.  In this case, the reference is to
           the previous command unless a previous history reference
           occurred on the same line, in which case this form repeats
           the previous reference.  Thus `!?foo?^| !$' gives the first
           and last arguments from the command matching `?foo?'.

           A special abbreviation of a history reference occurs when
           the first non-blank character of an input line is a `^|'.
           This is equivalent to `!:s^|', which provides a convenient
           shorthand for substitutions on the text of the previous
           line.  Thus `^|lb^|lib' fixes the spelling of `lib' in the
           previous command.  Finally, a history substitution may be
           surrounded with `{' and `}' if necessary to insulate it from
           the characters which follow.  Thus, after the command `ls
           -ld ~paul' we might enter `!{l}a' to create the command `ls
           -ld ~paula'.  Note that if you had entered `!la' the system
           would simply look for a command starting `la'.

           QQQQuuuuoooottttaaaattttiiiioooonnnnssss wwwwiiiitttthhhh '''' aaaannnndddd """"

           The quotation of strings by `'' and `"' can be used to
           prevent all or some of the remaining substitutions.  Strings
           enclosed in `'' are prevented any further interpretation.
           Strings enclosed in `"' may be expanded as described below.

           In both cases, the resulting text becomes all or part of a
           single word; only in one special case (see _C_o_m_m_a_n_d
           _S_u_b_s_t_i_t_u_t_i_o_n below) does a `"' quoted string yield parts of
           more than one word; `'' quoted strings never do.

           AAAAlllliiiiaaaassss ssssuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn

           The shell maintains a list of aliases which can be
           established, displayed and modified by the _a_l_i_a_s and _u_n_a_l_i_a_s
           commands.  After a command line is scanned, it is parsed
           into distinct commands and the first word of each command
           (read left-to-right) is checked to see if it has an alias.
           If it does, then the text which is the alias for that
           command is reread with the available history mechanism as
           though that command were the previous input line.  The
           resulting words replace the command and argument list.  If
           no reference is made to the history list, then the argument
           list is left unchanged.

           Thus, if the alias for `ls' is `ls -l', the command `ls
           /usr' would map to `ls -l /usr' and leave the argument list
           undisturbed.  Similarly, if the alias for `lookup' was `grep
           !^| /etc/passwd' then `lookup bill' would map to `grep bill
           /etc/passwd'.

           If an alias is found, the word transformation of the input



      Page 6                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           text is performed and the aliasing process begins again on
           the reformed input line.  Looping is prevented if the first
           word of the new text is the same as the old by flagging it
           to prevent further aliasing.  Other loops are detected and
           cause an error.

           Note that the mechanism allows aliases to introduce parser
           metasyntax.  Thus we can `alias print 'pr \!* | lpr'' to
           make a command which _p_r'_s its arguments to the line printer.

           VVVVaaaarrrriiiiaaaabbbblllleeee ssssuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn

           The shell maintains a set of variables, each of which has a
           value of zero or more words.  Some of these variables are
           set by the shell or referred to by it.  For instance, the
           _a_r_g_v variable is an image of the shell's argument list, and
           words of this variable's value are referred to in special
           ways.

           The values of variables may be displayed and changed by
           using the _s_e_t and _u_n_s_e_t commands.  Of the variables referred
           to by the shell, a number are toggles; the shell does not
           care what their value is, only whether they are set or not.
           For instance, the _v_e_r_b_o_s_e variable is a toggle which causes
           command input to be echoed.  The setting of this variable
           results from the ----vvvv command line option.

           Other operations treat variables numerically.  The `@'
           command permits numeric calculations to be performed and the
           result to be assigned to a variable.  Variable values are,
           however, always represented as (zero or more) strings.  For
           the purposes of numeric operations, the null string is
           considered to be zero, and the second and subsequent words
           of multiword values are ignored.

           After the input line is aliased and parsed, and before each
           command is executed, variable substitution is performed by
           `$' characters.  This expansion can be prevented by
           preceding the `$' with a `\', except within `"'s where it
           aaaallllwwwwaaaayyyyssss occurs, and within `''s where it nnnneeeevvvveeeerrrr occurs.
           Strings quoted by ``' are interpreted later (see _C_o_m_m_a_n_d
           _s_u_b_s_t_i_t_u_t_i_o_n below) so `$' substitution does not occur there
           until later, if at all.  A `$' is passed unchanged if
           followed by a blank, tab, or end-of-line.

           Input/output redirections are recognized before variable
           expansion, and are expanded separately.  Otherwise, the
           command name and entire argument list are expanded together.
           It is thus possible for the first (command) word to this
           point to generate more than one word, the first of which
           becomes the command name, and the rest of which become
           arguments.



      Page 7                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           Unless enclosed in `"' or given the `:q' modifier, the
           results of variable substitution may eventually be command
           and filename substituted.  Within `"' a variable whose value
           consists of multiple words expands to a (portion of) a
           single word, with the words of the variables value separated
           by blanks.  When the `:q' modifier is applied to a
           substitution, the variable will expand to multiple words
           with each word separated by a blank and quoted to prevent
           later command or filename substitution.

           The following metasequences are provided for introducing
           variable values into the shell input.  Except as noted, it
           is an error to reference a variable which is not set.

           $name
           ${name}
                Are replaced by the words of the value of variable
                _n_a_m_e, each separated by a blank.  Braces insulate _n_a_m_e
                from following characters which would otherwise be part
                of it.  Shell variables have names consisting of up to
                20 letters and digits starting with a letter.  The
                underscore character is considered a letter.
                If _n_a_m_e is not a shell variable, but is set in the
                environment, then that value is returned.  In this
                case, the :::: modifiers and the other forms given below
                will not be available.

           $name[selector]
           ${name[selector]}
                May be used to select only some of the words from the
                value of _n_a_m_e. The selector is subjected to `$'
                substitution and may consist of a single number or two
                numbers separated by a `-'.  The first word of a
                variables value is numbered `1'.  If the first number
                of a range is omitted it defaults to `1'.  If the last
                member of a range is omitted it defaults to `$#name'.
                The selector `*' selects all words.  It is not an error
                for a range to be empty if the second argument is
                omitted or in range.

           $#name
           ${#name}
                Gives the number of words in the variable.  This can be
                used later in a `[selector]'.

           $0
                Substitutes the name of the file from which command
                input is being read.  An error occurs if the name is
                not known.

           $number
           ${number}



      Page 8                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                Equivalent to `$argv[number]'.

           $*
                Equivalent to `$argv[*]'.

           The modifiers `:h', `:t', `:r', `:q' and `:x' can be applied
           to the substitutions above as can `:gh', `:gt' and `:gr'.
           If braces `{' '}' appear in the command form, then the
           modifiers must appear within the braces.  TTTThhhheeee ccccuuuurrrrrrrreeeennnntttt
           iiiimmmmpppplllleeeemmmmeeeennnnttttaaaattttiiiioooonnnn aaaalllllllloooowwwwssss oooonnnnllllyyyy oooonnnneeee ````::::'''' mmmmooooddddiiiiffffiiiieeeerrrr oooonnnn eeeeaaaacccchhhh ````$$$$''''
           eeeexxxxppppaaaannnnssssiiiioooonnnn....

           The following substitutions may not be modified with `:'
           modifiers.

           $?name
           ${?name}
                Substitutes the string `1' if name is set, `0' if it is
                not.

           $?0
                Substitutes `1' if the current input filename is known,
                `0' if it is not.

           $$
                Substitute the (decimal) process number of the (parent)
                shell.

           $<
                Substitutes a line from the standard input, with no
                further interpretation thereafter.  It can be used to
                read from the keyboard in a shell script.

           CCCCoooommmmmmmmaaaannnndddd aaaannnndddd ffffiiiilllleeeennnnaaaammmmeeee ssssuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn

           The remaining substitutions, command and filename
           substitution, are applied selectively to the arguments of
           builtin commands.  This means that portions of expressions
           which are not evaluated are not subjected to these
           expansions.  For commands which are not internal to the
           shell, the command name is substituted separately from the
           argument list.  This occurs very late, after input-output
           redirection is performed, and in a child of the main shell.

           CCCCoooommmmmmmmaaaannnndddd ssssuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn

           Command substitution is indicated by a command enclosed in
           ``'.  The output from such a command is normally broken into
           separate words at blanks, tabs and newlines, with null words
           being discarded.  This text then replaces the original
           string.  Within `"'s, only newlines force new words; blanks
           and tabs are preserved.



      Page 9                                                   (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           In any case, the single final newline does not force a new
           word.  Note that it is possible for a command substitution
           to yield only part of a word, even if the command outputs a
           complete line.

           FFFFiiiilllleeeennnnaaaammmmeeee ssssuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn

           If a word contains any of the characters `*', `?', `[' or
           `{' or begins with the character `~', then that word is a
           candidate for filename substitution, also known as
           `globbing'.  This word is then regarded as a pattern, and
           replaced with an alphabetically sorted list of file names
           which match the pattern.  In a list of words specifying
           filename substitution it is an error for no pattern to match
           an existing file name, but it is not required for each
           pattern to match.  Only the metacharacters `*', `?' and `['
           imply pattern matching, while the characters `~' and `{' are
           more akin to abbreviations.

           In matching filenames, the character `.' at the beginning of
           a filename or immediately following a `/', as well as the
           character `/' must be matched explicitly.  The character `*'
           matches any string of characters, including the null string.
           The character `?' matches any single character.  The
           sequence `[...]' matches any one of the characters enclosed.
           Within `[...]', a pair of characters separated by `-'
           matches any character that is alphabetically between them.

           The character `~' at the beginning of a filename is used to
           refer to home directories.  Standing alone, the `~'
           character expands to the invokers home directory as
           reflected in the value of the variable _h_o_m_e. When followed
           by a name consisting of letters, digits and `-' characters,
           the shell searches for a user with that name and substitutes
           their home directory.  Thus `~ken' might expand to
           `/usr/ken' and `~ken/chmach' to `/usr/ken/chmach'.  If the
           character `~' is followed by a character other than a letter
           or `/' or appears not at the beginning of a word, it is left
           undisturbed.

           The notation `a{b,c,d}e' is a shorthand for `abe ace ade'.
           Left to right order is preserved, with results of matches
           being sorted separately at a low level to preserve this
           order.  This construct may be nested.  Thus
           `~source/s1/{oldls,ls}.c' expands to `/usr/source/s1/oldls.c
           /usr/source/s1/ls.c' whether or not these files exist
           without any chance of error if the home directory for
           `source' is `/usr/source'.  Similarly `../{memo,*box}' might
           expand to `../memo ../box ../mbox'.  (Note that `memo' was
           not sorted with the results of matching `*box'.) As a
           special case, `{', `}' and `{}' are passed undisturbed.




      Page 10                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           IIIInnnnppppuuuutttt////oooouuuuttttppppuuuutttt

           The standard input and standard output of a command may be
           redirected with the following syntax:

           < name
                Open file _n_a_m_e (which is first variable, command and
                filename expanded) as the standard input.

           << word
                Read the shell input up to a line which is identical to
                _w_o_r_d. _W_o_r_d is not subjected to variable, filename or
                command substitution, and each input line is compared
                to _w_o_r_d before any substitutions are done on this input
                line.  Unless a quoting `\', `"', `'' or ``' appears in
                the _w_o_r_d variable and command substitution is performed
                on the intervening lines, allowing `\' to quote `$',
                `\' and ``'.  Commands which are substituted have all
                blanks, tabs, and newlines preserved, except for the
                final newline which is dropped.  The resultant text is
                placed in an anonymous temporary file, which is given
                to the command as standard input.

           > name
           >! name
           >& name
           >&! name
                The file _n_a_m_e is used as standard output.  If the file
                does not exist, then it is created; if the file exists,
                its is truncated, its previous contents being lost.

                If the variable _n_o_c_l_o_b_b_e_r is set, then the file must
                not exist or be a special character file (e.g. a
                terminal or `/dev/null') or an error will occur.  This
                helps prevent accidental destruction of files.  In this
                case, the `!' forms can be used to suppress this check.

                The forms involving `&' route the diagnostic output
                into the specified file as well as the standard output.
                _N_a_m_e is expanded in the same way as `<' input filenames
                are.

           >> name
           >>& name
           >>! name
           >>&! name
                Uses file _n_a_m_e as standard output like `>' but places
                output at the end of the file.  If the variable
                _n_o_c_l_o_b_b_e_r is set, then it is an error for the file not
                to exist unless one of the `!' forms is given.
                Otherwise similar to `>'.




      Page 11                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           A command receives the environment in which the shell was
           invoked as modified by the input-output parameters and the
           presence of the command in a pipeline.  Thus, unlike some
           previous shells, commands run from a file of shell commands
           have, by default, no access to the text of the commands;
           rather they receive the original standard input of the
           shell.  The `<<' mechanism should be used to present inline
           data.  This permits shell command scripts to function as
           components of pipelines and allows the shell to block read
           its input.  Note that the default standard input for a
           command is nnnnooootttt modified to be the empty file `/dev/null';
           rather the standard input remains as the original standard
           input of the shell.  If this is a terminal and if the
           process attempts to read from the terminal, then the process
           will block and the user will be notified (see JJJJoooobbbbssss above.)

           Diagnostic output may be directed through a pipe with the
           standard output.  Simply use the form `|&' rather than just
           `|'.

           EEEExxxxpppprrrreeeessssssssiiiioooonnnnssss

           A number of the builtin commands (to be described
           subsequently) take expressions, in which the operators are
           similar to those of C, with the same precedence.  These
           expressions appear in the @, _e_x_i_t, _i_f, and _w_h_i_l_e commands.
           The following operators are available:

                ||  &&  |  ^|  &  ==  !=  =~  !~  <=  >=  <  >  <<  >>
           +  -  *  /  %  !  ~  (  )

           Here the precedence increases to the right, `==' `!=' `=~'
           and `!~', `<=' `>=' `<' and `>', `<<' and `>>', `+' and `-',
           `*' `/' and `%' being, in groups, at the same level.  The
           `==' `!=' `=~' and `!~' operators compare their arguments as
           strings; all others operate on numbers.  The operators `=~'
           and `!~' are like `!=' and `==', except that the right hand
           side is a _p_a_t_t_e_r_n (containing, e.g. `*'s, `?'s and instances
           of `[...]') against which the left hand operand is matched.
           This reduces the need for use of the _s_w_i_t_c_h statement in
           shell scripts when all that is really needed is pattern
           matching.

           Strings which begin with `0' are considered octal numbers.
           Null or missing arguments are considered `0'.  The result of
           all expressions are strings, which represent decimal
           numbers.  It is important to note that no two components of
           an expression can appear in the same word; except when
           adjacent to components of expressions which are
           syntactically significant to the parser (`&' `|' `<' `>' `('
           `)') they should be surrounded by spaces.




      Page 12                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           Also available in expressions as primitive operands are
           command executions enclosed in `{' and `}' and file
           enquiries of the form `-_l  name' where _l is one of:

                r    read access
                w    write access
                x    execute access
                e    existence
                o    ownership
                z    zero size
                f    plain file
                d    directory

           The specified name is a command, which is expanded into a
           filename and then tested to see if it has the specified
           relationship to the real user.  If the file does not exist,
           or it is inaccessible, then all enquiries return false, i.e.
           `0'.  Command executions succeed, returning true, i.e. `1',
           if the command exits with status 0, otherwise they fail,
           returning false, i.e. `0'.  If more detailed status
           information is required, then the command should be executed
           outside of an expression and the variable _s_t_a_t_u_s examined.

           CCCCoooonnnnttttrrrroooollll fffflllloooowwww

           The shell contains a number of commands which can be used to
           regulate the flow of control in command files (shell
           scripts) and (in limited but useful ways) from terminal
           input.  These commands all operate by forcing the shell to
           reread or skip in its input and, due to the implementation,
           restrict the placement of some of the commands.

           The _f_o_r_e_a_c_h, _s_w_i_t_c_h, and _w_h_i_l_e statements, as well as the
           _i_f-_t_h_e_n-_e_l_s_e form of the _i_f statement, require that the
           major keywords appear in a single simple command on an input
           line as shown below.

           If the shell's input is not seekable, the shell buffers up
           input whenever a loop is being read and performs seeks in
           this internal buffer to accomplish the rereading implied by
           the loop.  (To the extent that this allows, backward goto's
           will succeed on non-seekable inputs.)

           BBBBuuuuiiiillllttttiiiinnnn ccccoooommmmmmmmaaaannnnddddssss

           Builtin commands are executed within the shell.  If a
           builtin command occurs as any component of a pipeline except
           the last component, then it is executed in a subshell.

           aaaalllliiiiaaaassss
           aaaalllliiiiaaaassss name
           aaaalllliiiiaaaassss name wordlist



      Page 13                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                The first form prints all aliases.  The second form
                prints the alias for name.  The final form assigns the
                specified _w_o_r_d_l_i_s_t as the alias of _n_a_m_e; _w_o_r_d_l_i_s_t is
                command and filename substituted.  _N_a_m_e is not allowed
                to be _a_l_i_a_s or _u_n_a_l_i_a_s.

           bbbbgggg
           bbbbgggg %%%%job ...
                Puts the current or specified jobs into the background,
                continuing them if they were stopped.

           bbbbrrrreeeeaaaakkkk
                Causes execution to resume after the _e_n_d of the nearest
                enclosing _f_o_r_e_a_c_h or _w_h_i_l_e. The remaining commands on
                the current line are executed.  Multi-level breaks are
                thus possible by writing them all on one line.

           bbbbrrrreeeeaaaakkkksssswwww
                Causes a break from a _s_w_i_t_c_h, resuming after the _e_n_d_s_w.

           ccccaaaasssseeee label:
                A label in a _s_w_i_t_c_h statement as discussed below.

           ccccdddd
           ccccdddd name
           cccchhhhddddiiiirrrr
           cccchhhhddddiiiirrrr name
                Change the shells working directory to directory _n_a_m_e.
                If no argument is given then change to the home
                directory of the user.
                If _n_a_m_e is not found as a subdirectory of the current
                directory (and does not begin with `/', `./' or `../'),
                then each component of the variable _c_d_p_a_t_h is checked
                to see if it has a subdirectory _n_a_m_e. Finally, if all
                else fails but _n_a_m_e is a shell variable whose value
                begins with `/', then this is tried to see if it is a
                directory.

           ccccoooonnnnttttiiiinnnnuuuueeee
                Continue execution of the nearest enclosing _w_h_i_l_e or
                _f_o_r_e_a_c_h. The rest of the commands on the current line
                are executed.

           ddddeeeeffffaaaauuuulllltttt::::
                Labels the default case in a _s_w_i_t_c_h statement.  The
                default should come after all _c_a_s_e labels.

           ddddiiiirrrrssss
                Prints the directory stack; the top of the stack is at
                the left, the first directory in the stack being the
                current directory.




      Page 14                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           eeeecccchhhhoooo wordlist
           eeeecccchhhhoooo ----nnnn wordlist
                The specified words are written to the shells standard
                output, separated by spaces, and terminated with a
                newline unless the ----nnnn option is specified.

           eeeellllsssseeee
           eeeennnndddd
           eeeennnnddddiiiiffff
           eeeennnnddddsssswwww
                See the description of the _f_o_r_e_a_c_h, _i_f, _s_w_i_t_c_h, and
                _w_h_i_l_e statements below.

           eeeevvvvaaaallll arg ...
                (As in _s_h(1).) The arguments are read as input to the
                shell and the resulting command(s) executed in the
                context of the current shell.  This is usually used to
                execute commands generated as the result of command or
                variable substitution, since parsing occurs before
                these substitutions.

           eeeexxxxeeeecccc command
                The specified command is executed in place of the
                current shell.

           eeeexxxxiiiitttt
           eeeexxxxiiiitttt(expr)
                The shell exits either with the value of the _s_t_a_t_u_s
                variable (first form) or with the value of the
                specified _e_x_p_r (second form).

           ffffgggg
           ffffgggg %%%%job ...
                Brings the current or specified jobs into the
                foreground, continuing them if they were stopped.

           ffffoooorrrreeeeaaaacccchhhh name (wordlist)
               ...
           eeeennnndddd
                The variable _n_a_m_e is successively set to each member of
                _w_o_r_d_l_i_s_t and the sequence of commands between this
                command and the matching _e_n_d are executed.  (Both
                _f_o_r_e_a_c_h and _e_n_d must appear alone on separate lines.)

                The builtin command _c_o_n_t_i_n_u_e may be used to continue
                the loop prematurely and the builtin command _b_r_e_a_k to
                terminate it prematurely.  When the _f_o_r_e_a_c_h command is
                read from the terminal, you will be prompted with `?'
                before any statements in the loop are executed.  If you
                make a mistake typing in a loop at the terminal you can
                rub it out.




      Page 15                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           gggglllloooobbbb wordlist
                Like _e_c_h_o but no `\' escapes are recognized and words
                are delimited by null characters in the output.  This
                is useful for programs which use the shell to expand a
                list of words into filenames.

           ggggoooottttoooo word
                The specified _w_o_r_d is a filename which is expanded to
                yield a string of the form `label'.  The shell rewinds
                its input as much as possible and searches for a line
                of the form `label:' possibly preceded by blanks or
                tabs.  Execution continues after the specified line.

           hhhhiiiissssttttoooorrrryyyy
           hhhhiiiissssttttoooorrrryyyy _n
           hhhhiiiissssttttoooorrrryyyy ----rrrr _n
           hhhhiiiissssttttoooorrrryyyy ----hhhh _n
                Displays the history event list; if _n is given, only
                the _n most recent events are printed.  The ----rrrr option
                reverses the order of printout to be most recent first
                rather than oldest first.  The ----hhhh option causes the
                history list to be printed without leading numbers.
                This is used to produce files suitable for sourcing
                using the -h option to _s_o_u_r_c_e.

           iiiiffff (expr) command
                If the specified expression evaluates true, then the
                single _c_o_m_m_a_n_d with arguments is executed.  Variable
                substitution on _c_o_m_m_a_n_d happens early, at the same time
                it does for the rest of the _i_f command.  _C_o_m_m_a_n_d must
                be a simple command, not a pipeline, a command list, or
                a parenthesized command list.  Input/output redirection
                occurs even if _e_x_p_r is false and the command is nnnnooootttt
                executed (this is a bug).

           iiiiffff (expr) tttthhhheeeennnn
               ...
           eeeellllsssseeee iiiiffff (expr2) tttthhhheeeennnn
               ...
           eeeellllsssseeee
               ...
           eeeennnnddddiiiiffff
                If the specified _e_x_p_r is true then the commands to the
                first _e_l_s_e are executed; else if _e_x_p_r_2 is true then the
                commands to the second else are executed, etc.  Any
                number of _e_l_s_e-_i_f pairs are possible; only one _e_n_d_i_f is
                needed.  The _e_l_s_e part is likewise optional.  (The
                words _e_l_s_e and _e_n_d_i_f must appear at the beginning of
                input lines; the _i_f must appear alone on its input line
                or after an _e_l_s_e.)

           jjjjoooobbbbssss



      Page 16                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           jjjjoooobbbbssss ----llll
                Lists the active jobs; given the ----llll options lists
                process id's in addition to the normal information.

           kkkkiiiillllllll %%%%job
           kkkkiiiillllllll ----sig %%%%job ...
           kkkkiiiillllllll pid
           kkkkiiiillllllll ----sig pid ...
           kkkkiiiillllllll ----llll
                Sends either the TERM (terminate) signal or the
                specified signal to the specified jobs or processes.
                Signals are either given by number or by names (as
                given in /_u_s_r/_i_n_c_l_u_d_e/_s_i_g_n_a_l._h, stripped of the prefix
                ``SIG'').  The signal names are listed by ``kill -l''.
                There is no default, saying just `kill' does not send a
                signal to the current job.  If the signal being sent is
                TERM (terminate) or HUP (hangup), then the job or
                process will be sent a CONT (continue) signal as well.

           llllooooggggiiiinnnn
                Terminate a login shell, replacing it with an instance
                of ////bbbbiiiinnnn////llllooooggggiiiinnnn.... This is one way to log off, included for
                compatibility with _s_h(1).

           llllooooggggoooouuuutttt
                Terminate a login shell.  Especially useful if
                _i_g_n_o_r_e_e_o_f is set.

           nnnniiiicccceeee
           nnnniiiicccceeee +number
           nnnniiiicccceeee command
           nnnniiiicccceeee +number command
                The first form sets the _n_i_c_e for this shell to 4.  The
                second form sets the _n_i_c_e to the given number.  The
                final two forms run command at priority 4 and _n_u_m_b_e_r
                respectively.  The super-user may specify negative
                niceness by using `nice -number ...'.  Command is
                always executed in a sub-shell, and the restrictions on
                commands in simple _i_f statements apply.

           nnnnoooohhhhuuuupppp
           nnnnoooohhhhuuuupppp command
                The first form can be used in shell scripts to cause
                hangups to be ignored for the remainder of the script.
                The second form causes the specified command to be run
                with hangups ignored.  All processes detached with `&'
                are effectively _n_o_h_u_p'_e_d.

           nnnnoooottttiiiiffffyyyy
           nnnnoooottttiiiiffffyyyy %%%%job ...
                Causes the shell to notify the user asynchronously when
                the status of the current or specified jobs changes;



      Page 17                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                normally notification is presented before a prompt.
                This is automatic if the shell variable _n_o_t_i_f_y is set.

           oooonnnniiiinnnnttttrrrr
           oooonnnniiiinnnnttttrrrr  -
           oooonnnniiiinnnnttttrrrr  label
                Control the action of the shell on interrupts.  The
                first form restores the default action of the shell on
                interrupts, which terminates shell scripts or causes a
                return to the terminal command input level.  The second
                form `onintr -' causes all interrupts to be ignored.
                The final form causes the shell to execute a `goto
                label' when an interrupt is received or a child process
                terminates because it was interrupted.

                In any case, if the shell is running detached and
                interrupts are being ignored, all forms of _o_n_i_n_t_r have
                no meaning and interrupts continue to be ignored by the
                shell and all invoked commands.

           ppppooooppppdddd
           ppppooooppppdddd +n
                Pops the directory stack, returning to the new top
                directory.  The argument `+_n' discards the _nth entry in
                the stack.  The elements of the directory stack are
                numbered from 0 starting at the top.

           ppppuuuusssshhhhdddd
           ppppuuuusssshhhhdddd name
           ppppuuuusssshhhhdddd +n
                With no arguments, _p_u_s_h_d exchanges the top two elements
                of the directory stack.  When a _n_a_m_e argument is given,
                _p_u_s_h_d changes to the new directory (ala _c_d) and pushes
                the old current working directory (as in _c_s_w) onto the
                directory stack.  When a numeric argument is given,
                _p_u_s_h_d rotates the _nth argument of the directory stack
                around to be the top element and changes to it.  The
                members of the directory stack are numbered from the
                top starting at 0.

           rrrreeeehhhhaaaasssshhhh
                Causes the internal hash table of the contents of the
                directories in the _p_a_t_h variable to be recomputed.
                This is needed if new commands are added to directories
                in the _p_a_t_h while you are logged in.  This should only
                be necessary if you add commands to one of your own
                directories, or if a systems programmer changes the
                contents of one of the system directories.

           rrrreeeeppppeeeeaaaatttt count command
                The specified _c_o_m_m_a_n_d, which is subject to the same
                restrictions as the _c_o_m_m_a_n_d in the one line _i_f



      Page 18                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                statement above, is executed _c_o_u_n_t times.  I/O
                redirections occur exactly once, even if _c_o_u_n_t is 0.

           sssseeeetttt
           sssseeeetttt name
           sssseeeetttt name=word
           sssseeeetttt name[index]=word
           sssseeeetttt name=(wordlist)
                The first form of the command shows the value of all
                shell variables.  Variables which have other than a
                single word as their value appear as a parenthesized
                word list.  The second form sets _n_a_m_e to the null
                string.  The third form sets _n_a_m_e to the single _w_o_r_d.
                The fourth form sets the _i_n_d_e_x'_t_h component of name to
                word; this component must already exist.  The final
                form sets _n_a_m_e to the list of words in _w_o_r_d_l_i_s_t. In all
                cases, the value is expanded as described in the
                _C_o_m_m_a_n_d _a_n_d _f_i_l_e_n_a_m_e _s_u_b_s_t_i_t_u_t_i_o_n section.

                These arguments may be repeated to set multiple values
                in a single set command.  Note however, that variable
                expansion happens for all arguments before any setting
                occurs.

           sssseeeetttteeeennnnvvvv name value
                Sets the value of environment variable _n_a_m_e to be
                _v_a_l_u_e, a single string.  The most commonly used
                environment variable USER, TERM, and PATH are
                automatically imported to and exported from the _c_s_h
                variables _u_s_e_r, _t_e_r_m, and _p_a_t_h; there is no need to use
                _s_e_t_e_n_v for these.

           sssshhhhiiiifffftttt
           sssshhhhiiiifffftttt variable
                The members of _a_r_g_v are shifted to the left, discarding
                _a_r_g_v[_1]. It is an error for _a_r_g_v not to be set or to
                have less than one word as value.  The second form
                performs the same function on the specified variable.

           ssssoooouuuurrrrcccceeee name
           ssssoooouuuurrrrcccceeee ----hhhh name
                The shell reads commands from _n_a_m_e. _S_o_u_r_c_e commands may
                be nested; if they are nested too deeply, the shell may
                run out of file descriptors.  An error in a _s_o_u_r_c_e at
                any level terminates all nested _s_o_u_r_c_e commands.
                Normally input during _s_o_u_r_c_e commands is not placed on
                the history list; the -h option causes the commands to
                be placed in the history list without being executed.

           ssssttttoooopppp
           ssssttttoooopppp %%%%job ...
                Stops the current or specified job which is executing



      Page 19                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                in the background.

           ssssuuuussssppppeeeennnndddd
                Causes the shell to stop in its tracks, much as if it
                had been sent a stop signal with ^^^^ZZZZ.  This is most
                often used to stop shells started by _s_u(1).

           sssswwwwiiiittttcccchhhh (string)
           ccccaaaasssseeee str1:
               ...
             bbbbrrrreeeeaaaakkkksssswwww
           ...
           ddddeeeeffffaaaauuuulllltttt::::
               ...
             bbbbrrrreeeeaaaakkkksssswwww
           eeeennnnddddsssswwww
                Each case label is successively matched against the
                specified _s_t_r_i_n_g, which is the first command and
                filename expanded.  The filename substitution
                characters `*', `?' and `[...]' may be used in the case
                labels, which are variable expanded.  If none of the
                labels match before a `default' label is found, then
                the execution begins after the default label.  Each
                case label and the default label must appear at the
                beginning of a line.  The command _b_r_e_a_k_s_w causes
                execution to continue after the _e_n_d_s_w. Otherwise
                control may fall through case labels and default labels
                as in C.  If no label matches and there is no default,
                execution continues after the _e_n_d_s_w.

           ttttiiiimmmmeeee
           ttttiiiimmmmeeee command
                With no argument, a summary of time used by this shell
                and its children is printed.  If arguments are given,
                the specified simple command is timed and a time
                summary as described under the _t_i_m_e variable is
                printed.  If necessary, an extra shell is created to
                print the time statistic when the command completes.

           uuuummmmaaaasssskkkk
           uuuummmmaaaasssskkkk value
                The file creation mask is displayed (first form) or set
                to the specified value (second form).  The mask is
                given in octal.  Common values for the mask are 002 and
                022.  A value of 022 gives all access to the group and
                read and execute access to others; 022 gives all
                access, except no write access for users in the group
                or others.

           uuuunnnnaaaalllliiiiaaaassss pattern
                All aliases whose names match the specified pattern are
                discarded.  Thus, all aliases are removed by `unalias



      Page 20                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                *'.  It is not an error for nothing to be _u_n_a_l_i_a_s_e_d.

           uuuunnnnhhhhaaaasssshhhh
                Use of the internal hash table to speed location of
                executed programs is disabled.

           uuuunnnnsssseeeetttt pattern
                All variables whose names match the specified pattern
                are removed.  Thus all variables are removed by `unset
                *'; this has noticeably distasteful side-effects.  It
                is not an error for nothing to be _u_n_s_e_t.

           uuuunnnnsssseeeetttteeeennnnvvvv pattern
                Removes all variables whose name match the specified
                pattern from the environment.  See also the _s_e_t_e_n_v
                command above and _p_r_i_n_t_e_n_v(1).

           wwwwaaaaiiiitttt
                All background jobs are waited for.  If the shell is
                interactive, then an interrupt can disrupt the wait, at
                which time the shell prints names and job numbers of
                all jobs known to be outstanding.

           wwwwhhhhiiiilllleeee (expr)
               ...
           eeeennnndddd
                While the specified expression evaluates non-zero, the
                commands between the _w_h_i_l_e and the matching _e_n_d are
                evaluated.  _B_r_e_a_k and _c_o_n_t_i_n_u_e may be used to terminate
                or continue the loop prematurely.  (The _w_h_i_l_e and _e_n_d
                must appear alone on their input lines.) If the input
                is a terminal, prompting occurs here the first time
                through the loop, as with the _f_o_r_e_a_c_h statement.

           %%%%job
                Brings the specified job into the foreground.

           %%%%job &&&&
                Continues the specified job in the background.

           @@@@
           @@@@ name = expr
           @@@@ name[index] = expr
                The first form prints the values of all the shell
                variables.  The second form sets the specified _n_a_m_e to
                the value of _e_x_p_r. If the expression contains `<', `>',
                `&' or `|' then at least this part of the expression
                must be placed within `(' `)'.  The third form assigns
                the value of _e_x_p_r to the _i_n_d_e_x'_t_h argument of _n_a_m_e.
                Both _n_a_m_e and its _i_n_d_e_x'_t_h component must already
                exist.




      Page 21                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                The operators `*=', `+=', etc are available as in C.
                The space separating the name from the assignment
                operator is optional.  Spaces are, however, mandatory
                in separating components of _e_x_p_r, which would otherwise
                be single words.

                Special postfix `++' and `--' operators increment and
                decrement _n_a_m_e respectively, i.e. `@  i++'.

           PPPPrrrreeee----ddddeeeeffffiiiinnnneeeedddd aaaannnndddd eeeennnnvvvviiiirrrroooonnnnmmmmeeeennnntttt vvvvaaaarrrriiiiaaaabbbblllleeeessss

           The following variables have special meaning to the shell.
           Of these, _a_r_g_v, _c_w_d, _h_o_m_e, _p_a_t_h, _p_r_o_m_p_t, _s_h_e_l_l and _s_t_a_t_u_s,
           are always set by the shell.  Except for _c_w_d and _s_t_a_t_u_s this
           setting occurs only at initialization; these variables will
           not then be modified unless this is done explicitly by the
           user.

           This shell copies the environment variable USER into the
           variable _u_s_e_r, TERM into _t_e_r_m, and HOME into _h_o_m_e, and
           copies these back into the environment whenever the normal
           shell variables are reset.  The environment variable PATH is
           handled in the same way. Once the path is set in the ._c_s_h_r_c
           file, inferior _c_s_h processes will import the definition of
           _p_a_t_h from the environment, and re-export it if you then
           change it.

           aaaarrrrggggvvvv           Set to the arguments to the shell, it is from
                          this variable that positional parameters are
                          substituted, i.e. `$1' is replaced by
                          `$argv[1]', etc.

           ccccddddppppaaaatttthhhh         Gives a list of alternate directories
                          searched to find subdirectories in _c_h_d_i_r
                          commands.

           ccccwwwwdddd            The full pathname of the current directory.

           eeeecccchhhhoooo           Set when the ----xxxx command line option is given.
                          Causes each command and its arguments to be
                          echoed just before it is executed.  For non-
                          builtin commands, all expansions occur before
                          echoing.  Builtin commands are echoed before
                          command and filename substitution, since
                          these substitutions are then done
                          selectively.

           hhhhiiiissssttttcccchhhhaaaarrrrssss      Can be given a string value to change the
                          characters used in history substitution.  The
                          first character of its value is used as the
                          history substitution character, replacing the
                          default character !.  The second character of



      Page 22                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                          its value replaces the character |^ in quick
                          substitutions.

           hhhhiiiissssttttoooorrrryyyy        Can be given a numeric value to control the
                          size of the history list.  Any command which
                          has been referenced in this many events will
                          not be discarded.  Too large values of
                          _h_i_s_t_o_r_y may run the shell out of memory.  The
                          last executed command is always saved on the
                          history list.

           hhhhoooommmmeeee           The home directory of the invoker,
                          initialized from the environment.  The
                          filename expansion of `~~~~' refers to this
                          variable.

           iiiiggggnnnnoooorrrreeeeeeeeooooffff      If set, the shell ignores end-of-file from
                          input devices which are terminals.  This
                          prevents shells from accidentally being
                          killed by control-D's.

           mmmmaaaaiiiillll           The files where the shell checks for mail.
                          This is done after each command completion
                          which will result in a prompt, if a specified
                          interval has elapsed.  The shell says `You
                          have new mail.' if the file exists with an
                          access time not greater than its modify time.

                          If the first word of the value of _m_a_i_l is
                          numeric, it specifies a different mail
                          checking interval (in seconds) than the
                          default, which is 10 minutes.

                          If multiple mail files are specified, then
                          the shell says `New mail in _n_a_m_e' when there
                          is mail in the file _n_a_m_e.

           nnnnoooocccclllloooobbbbbbbbeeeerrrr      As described in the section on _I_n_p_u_t/_o_u_t_p_u_t,
                          restrictions are placed on output redirection
                          to insure that files are not accidentally
                          destroyed, and that `>>' redirections refer
                          to existing files.

           nnnnoooogggglllloooobbbb         If set, filename expansion is inhibited.
                          This is useful in shell scripts which are not
                          dealing with filenames, or after a list of
                          filenames has been obtained and further
                          expansions are not desired.

           nnnnoooonnnnoooommmmaaaattttcccchhhh      If set, it is not an error for a filename
                          expansion to not match any existing files;
                          rather the primitive pattern is returned.  It



      Page 23                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



                          is still an error for the primitive pattern
                          to be malformed, i.e.  `echo [' still gives
                          an error.

           nnnnoooottttiiiiffffyyyy         If set, the shell notifies asynchronously of
                          job completions.  The default is to present
                          job completions just before printing a
                          prompt.

           ppppaaaatttthhhh           Each word of the path variable specifies a
                          directory in which commands are to be sought
                          for execution.  A null word specifies the
                          current directory.  If there is no _p_a_t_h
                          variable, then only full path names will
                          execute.  The usual search path is `.',
                          `/bin' and `/usr/bin', but this may vary from
                          system to system.  For the super-user, the
                          default search path is `/etc', `/bin' and
                          `/usr/bin'.  A shell which is given neither
                          the ----cccc nor the ----tttt option will normally hash
                          the contents of the directories in the _p_a_t_h
                          variable after reading ._c_s_h_r_c, and each time
                          the _p_a_t_h variable is reset.  If new commands
                          are added to these directories while the
                          shell is active, it may be necessary to give
                          the _r_e_h_a_s_h or the commands may not be found.

           pppprrrroooommmmpppptttt         The string printed before each command is
                          read from an interactive terminal input.  If
                          a `!' appears in the string, it will be
                          replaced by the current event number, unless
                          a preceding `\' is given.  Default is `% ',
                          or `# ' for the super-user.

           ssssaaaavvvveeeehhhhiiiisssstttt       This variable is given a numeric value to
                          control the number of entries of the history
                          list that are saved in ~/.history when the
                          user logs out.  Any command which has been
                          referenced in this many events will be saved.
                          During start up, the shell sources ~/.history
                          into the history list, enabling history to be
                          saved across logins.  Large _s_a_v_e_h_i_s_t values
                          will slow down the shell during start up.

           sssshhhheeeellllllll          The file in which the shell resides.  This is
                          used in forking shells to interpret files
                          which have execute bits set, but are not
                          executable by the system.  (See the
                          description of _N_o_n-_b_u_i_l_t_i_n _C_o_m_m_a_n_d _E_x_e_c_u_t_i_o_n
                          below.) Initialized to the (system-dependent)
                          home of the shell.




      Page 24                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           ssssttttaaaattttuuuussss         The status returned by the last command.  If
                          it terminated abnormally, then 0200 is added
                          to the status.  Builtin commands which fail,
                          return exit status `1'; all other builtin
                          commands set status `0'.

           ttttiiiimmmmeeee           Controls automatic timing of commands.  If
                          set, then any command which takes more than
                          this many cpu seconds will, upon termination,
                          print a line giving user, system, and real
                          times, along with a utilization percentage
                          (which is the ratio of user plus system times
                          to real time).

           vvvveeeerrrrbbbboooosssseeee        Set by the ----vvvv command line option, causes the
                          words of each command to be printed after
                          history substitution.

           NNNNoooonnnn----bbbbuuuuiiiillllttttiiiinnnn ccccoooommmmmmmmaaaannnndddd eeeexxxxeeeeccccuuuuttttiiiioooonnnn

           When a command to be executed is found to not be a builtin
           command, the shell attempts to execute the command via
           _e_x_e_c_v_e(2).  Each word in the variable _p_a_t_h names a directory
           from which the shell will attempt to execute the command.
           If it is given neither a ----cccc nor a ----tttt option, the shell will
           hash the names in these directories into an internal table
           so that it will only try an _e_x_e_c in a directory if there is
           a possibility that the command resides there.  This greatly
           speeds command location when a large number of directories
           are present in the search path.  If this mechanism has been
           turned off (via _u_n_h_a_s_h), or if the shell was given a ----cccc or
           ----tttt argument, and in any case in which each directory
           component of _p_a_t_h does not begin with a `/', the shell
           concatenates with the given command name to form a path name
           of a file which it then attempts to execute.

           Parenthesized commands are always executed in a subshell.
           For example, `(cd ; pwd) ; pwd' prints the _h_o_m_e directory
           and leaves you where you were (printing this after the home
           directory), while `cd ; pwd' leaves you in the _h_o_m_e
           directory.  Parenthesized commands are most often used to
           prevent _c_h_d_i_r from affecting the current shell.

           If the file has execute permissions, but is not an
           executable binary to the system, then it is assumed to be a
           file containing shell commands and a new shell is spawned to
           read it.

           If there is an _a_l_i_a_s for _s_h_e_l_l, then the words of the alias
           will be prepended to the argument list to form the shell
           command.  The first word of the _a_l_i_a_s should be the full
           path name of the shell (e.g. `$shell').  Note that this is a



      Page 25                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           special, late occurring, case of _a_l_i_a_s substitution, which
           only allows words to be prepended to the argument list
           without modification.

           AAAArrrrgggguuuummmmeeeennnntttt lllliiiisssstttt pppprrrroooocccceeeessssssssiiiinnnngggg

           If argument 0 to the shell is `-', then this is a login
           shell.  The flag arguments are interpreted as follows:

           ----cccc   Commands are read from the (single) following argument
                which must be present.  Any remaining arguments are
                placed in _a_r_g_v.

           ----eeee   The shell exits if any invoked command terminates
                abnormally or yields a non-zero exit status.

           ----ffff   The shell will start faster, because it will neither
                search for nor execute commands from the file

           ----iiii   The shell is interactive and prompts for its top-level
                input, even if it appears to not be a terminal.  Shells
                are interactive without this option if their inputs and
                outputs are terminals.

           ----nnnn   Commands are parsed, but not executed.  This aids in
                syntactic checking of shell scripts.

           ----ssss   Command input is taken from the standard input.

           ----tttt   A single line of input is read and executed.  A `\' may
                be used to escape the newline at the end of this line
                and continue onto another line.

           ----vvvv   Causes the _v_e_r_b_o_s_e variable to be set, with the effect
                that command input is echoed after history
                substitution.

           ----xxxx   Causes the _e_c_h_o variable to be set, so that commands
                are echoed immediately before execution.

           ----VVVV   Causes the _v_e_r_b_o_s_e variable to be set even before
                ._c_s_h_r_c is executed.

           ----XXXX   Is to ----xxxx as ----VVVV is to ----vvvv....

           If, after the flag arguments are processed, arguments remain
           but none of the ----cccc,,,, ----iiii,,,, ----ssss,,,, or ----tttt options were given, the
           first argument is taken as the name of a file of commands to
           be executed.  The shell opens this file, and saves its name
           for possible resubstitution by `$0'.  Since many systems use
           either the standard version 6 or version 7 shells whose
           shell scripts are not compatible with this shell, the shell



      Page 26                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           will execute such a `standard' shell if the first character
           of a script is not a `#' (i.e. if the script does not start
           with a comment).  Remaining arguments initialize the
           variable _a_r_g_v.

           SSSSiiiiggggnnnnaaaallll hhhhaaaannnnddddlllliiiinnnngggg

           The shell normally ignores _q_u_i_t signals.  Jobs running
           detached (either by `&' or the _b_g or %%%%............ &&&& commands) are
           immune to signals generated from the keyboard, including
           hangups.  Other signals have the same values the shell
           inherited from its parent.  The way the shell handles
           interrupts and terminate signals in shell scripts can be
           controlled by _o_n_i_n_t_r. Login shells catch the _t_e_r_m_i_n_a_t_e
           signal; otherwise this signal is passed on to children from
           the state in the shell's parent.  In no case are interrupts
           allowed when a login shell is reading the file `.logout'.

      AAAAUUUUTTTTHHHHOOOORRRR
           University of California, Berkeley

      FFFFIIIILLLLEEEESSSS
           ~/.cshrc         Read at beginning of execution by each shell.
           ~/.login         Read by login shell, after `.cshrc' at login.
           ~/.logout        Read by login shell, at logout.
           /bin/sh          Standard shell, for shell scripts not starting with a `#'.
           /tmp/sh*         Temporary file for `<<'.
           /etc/passwd      Source of home directories for `~name'.

      LLLLIIIIMMMMIIIITTTTAAAATTTTIIIIOOOONNNNSSSS
           Words can be no longer than 1024 characters.  The system
           limits argument lists to 4096 characters.  The number of
           arguments to a command that involve filename expansion is
           limited to 1/6'th the number of characters allowed in an
           argument list.  Command substitutions may substitute no more
           characters than are allowed in an argument list.  To detect
           looping, the shell restricts the number of _a_l_i_a_s
           substitutions on a single line to 20.

      SSSSEEEEEEEE AAAALLLLSSSSOOOO
           sh(1), access(2), execve(2), fork(2), kill(2), pipe(2),
           signal(2), umask(2), wait(2), termio(7), a.out(4),
           environ(5), `An introduction to the C shell' in the RRRROOOOSSSS
           UUUUttttiiiilllliiiittttyyyy GGGGuuuuiiiiddddeeee.

      BBBBUUUUGGGGSSSS
           When a command is restarted from a stop, the shell prints
           the directory it which it started if different from the
           current directory.  The directory printed will be incorrect
           if the job has changed directories internally.

           Shell builtin functions are not stoppable/restartable.



      Page 27                                                  (9010-E)






      CCCCSSSSHHHH((((1111))))                      ((((bbbbssssdddd 4444....2222))))                      CCCCSSSSHHHH((((1111))))



           Command sequences of the form `a ; b ; c' are also not
           handled gracefully when stopping is attempted.  If you
           suspend `b', the shell will then immediately execute `c'.
           This is especially noticeable if this expansion results from
           an _a_l_i_a_s. You can place the sequence of commands in ()'s to
           force it to a subshell, i.e. `( a ; b ; c )'.

           Control over tty output after processes are started is
           primitive; perhaps this will inspire someone to work on a
           good virtual terminal interface.  If a better virtual
           terminal interface existed, things could be done with output
           control.

           Alias substitution is most often used to clumsily simulate
           shell procedures; shell procedures should be provided rather
           than aliases.

           Commands within loops, prompted for by `?', are not placed
           in the _h_i_s_t_o_r_y list.  Control structure should be parsed
           rather than being recognized as built-in commands.  This
           would allow control commands to be placed anywhere, to be
           combined with `|', and to be used with `&' and `;'
           metasyntax.

           It should be possible to use the `:' modifiers on the output
           of command substitutions.  All and more than one `:'
           modifier should be allowed on `$' substitutions.




























      Page 28                                                  (9010-E)



