NAME
     sh - shell, the standard UNIX system command interpreter and
     command-level language

SYNOPSIS
     sh [ -acefhiknstuvx ] [ arguments ]

DESCRIPTION
     sh, the Bourne shell, is the  standard  UNIX-system  command
     interpreter.  It executes commands read from a terminal or a
     file.

  Definitions
     A blank is a TAB or a SPACE character.  A name is a sequence
     of  letters,  digits, or underscores beginning with a letter
     or underscore.  A parameter is a name, a digit,  or  any  of
     the characters *, @, #, ?, -, $, and ! .

  Invocation
     If the shell is  invoked  through  execve(2V),  exec(),  see
     execl(3V),  and the first character of argument zero is `-',
     commands are  initially  read  from  /etc/profile  and  from
     $HOME/.profile,  if  such files exist.  Thereafter, commands
     are read as described below, which is also the case when the
     shell is invoked as sh.

OPTIONS
     The options below are interpreted by the shell on invocation
     only;  unless  the  -c  or -s option is specified, the first
     argument is assumed to be the name of a file containing com-
     mands,  and the remaining arguments are passed as positional
     parameters for use with the commands that file contains.

     -i             If the -i option is present or if  the  shell
                    input  and output are attached to a terminal,
                    this shell is interactive.  In this case TER-
                    MINATE  is ignored (so that `kill 0' does not
                    kill an interactive shell) and  INTERRUPT  is
                    caught and ignored (so that wait is interrup-
                    tible).  In all cases, QUIT is ignored by the
                    shell.

     -s             If the -s option is present or  if  no  argu-
                    ments remain commands are read from the stan-
                    dard input.  Any remaining arguments  specify
                    the   positional  parameters.   Shell  output
                    (except for Special Commands) is  written  to
                    file descriptor 2.

     -c string      If the -c option is present commands are read
                    from string.

     The remaining options and arguments are described under  the
     set command, under Special Commands, below.

USAGE
     Refer to Doing More with SunOS for  more  information  about
     using the shell as a programming language.

  Commands
     A simple command is a sequence of nonblank  words  separated
     by blanks.  The first word specifies the name of the command
     to be executed.  Except as specified  below,  the  remaining
     words  are  passed as arguments to the invoked command.  The
     command name is passed as argument 0 (see execve(2V)).   The
     value  of  a  simple  command  is its exit status if it ter-
     minates normally, or (octal)  200+status  if  it  terminates
     abnormally (see sigvec(2) for a list of status values).

     A pipeline is a sequence of one or more  commands  separated
     by  `|'  (or,  for  historical  compatibility, by `^').  The
     standard output of each command but the last is connected by
     a pipe (see pipe(2V)) to the standard input of the next com-
     mand.  Each command is run as a separate process; the  shell
     normally  waits  for  the  last  command to terminate before
     prompting for or accepting the next input  line.   The  exit
     status of a pipeline is the exit status of its last command.

     A list is a sequence of one or more simple commands or pipe-
     lines,  separated by `;', `&', `&&', or `||', and optionally
     terminated by `;' or `&'.  Of these four  symbols,  `;'  and
     `&'  have equal precedence, which is lower than that of `&&'
     and `||'.  The symbols `&&' and `||' also  have  equal  pre-
     cedence.   A semicolon (;) sequentially executes the preced-
     ing pipeline; an ampersand (&) asynchronously  executes  the
     preceding  pipeline  (the shell does not wait for that pipe-
     line to finish).  The symbols && and || are used to indicate
     conditional  execution  of the list that follows.  With && ,
     list is executed only if the preceding pipeline (or command)
     returns  a zero exit status.  With ||, list is executed only
     if the preceding pipeline (or  command)  returns  a  nonzero
     exit  status.  An arbitrary number of NEWLINE characters may
     appear in a list, instead of  semicolons,  to  delimit  com-
     mands.

     A command is either a simple command or one of the following
     constructions.   Unless otherwise stated, the value returned
     by a command is that of the last simple command executed  in
     the construction.

     for name [ in word ... ] do list done
          Each time a for command is executed, name is set to the
          next  word taken from the in word list.  If in word ...
          is omitted, then the for command executes the  do  list
          once  for  each  positional  parameter that is set (see
          Parameter Substitution  below).   Execution  ends  when
          there are no more words in the list.

     case word in [pattern[ | pattern] ... ) list ;; ] ... esac
          A case command executes the list  associated  with  the
          first  pattern that matches word.  The form of the pat-
          terns is the same as that used for filename  generation
          (see  Filename Generation) except that a slash, a lead-
          ing dot, or a dot immediately following  a  slash  need
          not be matched explicitly.

     if list then list [ elif list then list ] ... [ else list  ]
          fi
          The list following if is executed and, if it returns  a
          zero  exit status, the list following the first then is
          executed.  Otherwise, the list following elif  is  exe-
          cuted and, if its value is zero, the list following the
          next then is executed.  Failing that, the else list  is
          executed.   If  no  else list or then list is executed,
          then the if command returns a zero exit status.

     while list do list done
          A while command repeatedly executes the while list and,
          if  the  exit status of the last command in the list is
          zero, executes the do list;  otherwise  the  loop  ter-
          minates.   If  no commands in the do list are executed,
          then the while command  returns  a  zero  exit  status;
          until  may be used in place of while to negate the loop
          termination test.

     (list)
          Execute list in a subshell.

     {list;}
          list is simply executed.

     name () {list;}
          Define a function which is  referenced  by  name.   The
          body  of the function is the list of commands between {
          and }.  Execution of functions is described below  (see
          Execution).

     The following words are only recognized as the first word of
     a command and when not quoted:

     if then else elif fi case esac for while until do done { }

  Comments
     A word beginning with # and all the following characters  up
     to a NEWLINE are ignored.

  Command Substitution
     The shell reads commands from the string between  two  grave
     accents (``) and the standard output from these commands may
     be used as all or part of a word.  Trailing NEWLINE  charac-
     ters from the standard output are removed.

     No interpretation is done on the string before the string is
     read,  except to remove backslashes (\) used to escape other
     characters.  Backslashes may  be  used  to  escape  a  grave
     accent  (`)  or another backslash (\) and are removed before
     the command string is read.  Escaping grave  accents  allows
     nested  command  substitution.   If the command substitution
     lies within a pair of double quotes (" ...` ...` ...  "),  a
     backslash  used  to  escape  a  double  quote  (\")  will be
     removed; otherwise, it will be left intact.

     If a backslash is used to escape a NEWLINE character  (\NEW-
     LINE),  both  the backslash and the NEWLINE are removed (see
     Quoting, later).  In addition, backslashes  used  to  escape
     dollar  signs  (\$) are removed.  Since no interpretation is
     done on the command string before it is  read,  inserting  a
     backslash   to   escape   a   dollar  sign  has  no  effect.
     Backslashes that precede characters other than \, `, ", NEW-
     LINE, and $ are left intact when the command string is read.

  Parameter Substitution
     The character $ is used to introduce  substitutable  parame-
     ters.   There  are  two  types of parameters, positional and
     keyword.  If parameter is a digit, it is a positional param-
     eter.   Positional parameters may be assigned values by set.
     Keyword parameters (also known as variables) may be assigned
     values by writing:

          name=value [ name=value ] ...

     Pattern-matching is not performed on value.  There cannot be
     a function and a variable with the same name.

     ${parameter}
          The value, if any, of  the  parameter  is  substituted.
          The braces are required only when parameter is followed
          by a letter, digit, or underscore that  is  not  to  be
          interpreted  as  part of its name.  If parameter is `*'
          or `@', all the positional  parameters,  starting  with
          $1,  are  substituted  (separated by SPACE characters).
          Parameter $0 is set from argument zero when  the  shell
          is invoked.
     If the colon (:) is omitted from the following  expressions,
     the shell only checks whether parameter is set or not.
     ${parameter:-word}
          If parameter is set  and  is  nonnull,  substitute  its
          value; otherwise substitute word.

     ${parameter:=word}
          If parameter is not set or is null set it to word;  the
          value  of  the  parameter  is  substituted.  Positional
          parameters may not be assigned to in this way.
     ${parameter:?word}
          If parameter is set  and  is  nonnull,  substitute  its
          value;  otherwise,  print word and exit from the shell.
          If word is omitted, the message `parameter null or  not
          set' is printed.
     ${parameter:+word}
          If parameter is set and is  nonnull,  substitute  word;
          otherwise substitute nothing.

     In the above, word is not evaluated unless it is to be  used
     as  the  substituted string, so that, in the following exam-
     ple, pwd is executed only if d is not set or is null:

          echo ${d:-`pwd`}

     The following parameters are automatically set by the shell:

          #    The number of positional parameters in decimal.
          -    Flags supplied to the shell on  invocation  or  by
               the set command.
          ?    The decimal value returned by  the  last  synchro-
               nously executed command.
          $    The process number of this shell.
          !    The process number of the last background  command
               invoked.

     The following parameters are used by the shell:

          HOME           The default  argument  (home  directory)
                         for the cd command.

          PATH           The search path for commands (see Execu-
                         tion below).

          CDPATH         The search path for the cd command.

          MAIL           If this parameter is set to the name  of
                         a  mail  file and the MAILPATH parameter
                         is not set, the shell informs  the  user
                         of  the arrival of mail in the specified
                         file.







          MAILCHECK      This parameter specifies how  often  (in
                         seconds)  the  shell  will check for the
                         arrival of mail in the  files  specified
                         by the MAILPATH or MAIL parameters.  The
                         default  value  is   600   seconds   (10
                         minutes).   If  set to 0, the shell will
                         check before each primary prompt.

          MAILPATH       A colon (:) separated list of filenames.
                         If  this  parameter  is  set,  the shell
                         informs the user of the arrival of  mail
                         in  any  of  the  specified  files. Each
                         filename can be followed by % and a mes-
                         sage  that  will  be  printed  when  the
                         modification time changes.  The  default
                         message is `you have mail'.

          PS1            Primary prompt string, by default `$ '.

          PS2            Secondary prompt string, by  default  `>
                         '.

          IFS            Internal  field   separators,   normally
                         SPACE, TAB, and NEWLINE.

          SHELL          When the shell is invoked, it scans  the
                         environment  (see Environment below) for
                         this name.

     The shell gives default values to PATH, PS1, PS2,  MAILCHECK
     and IFS.  HOME and MAIL are set by login(1).

  Blank Interpretation
     After parameter and command  substitution,  the  results  of
     substitution  are scanned for internal field separator char-
     acters (those found in IFS) and split  into  distinct  argu-
     ments  where such characters are found.  Explicit null argu-
     ments ("" or '')  are  retained.   Implicit  null  arguments
     (those  resulting  from  parameters that have no values) are
     removed.

  Input/Output
     A command's input and output may be redirected using a  spe-
     cial  notation  interpreted by the shell.  The following may
     appear anywhere in a simple command or may precede or follow
     a  command  and  are  not  passed on to the invoked command.
     Note: parameter and command substitution occurs before  word
     or digit is used.

     <word         Use file word as standard input (file descrip-
                   tor 0).

     >word         Use  file  word  as  standard   output   (file
                   descriptor  1).  If the file does not exist it
                   is created; otherwise, it is truncated to zero
                   length.

     >>word        Use file word as standard output.  If the file
                   exists  output  is  appended  to  it (by first
                   seeking to the EOF); otherwise,  the  file  is
                   created.

     <<[-]word     After parameter and  command  substitution  is
                   done  on  word,  the shell input is read up to
                   the first  line  that  literally  matches  the
                   resulting word, or to an EOF. If, however, `-'
                   is appended to:

                        +   leading TAB characters  are  stripped
                            from  word  before the shell input is
                            read (but after parameter and command
                            substitution is done on word),

                        +   leading TAB characters  are  stripped
                            from  the  shell  input as it is read
                            and before each line is compared with
                            word, and

                        +   shell input is read up to  the  first
                            line   that   literally  matches  the
                            resulting word, or to an EOF.

                   If any character of word is quoted, (see Quot-
                   ing,  later), no additional processing is done
                   to the shell input.  If no characters of  word
                   are quoted:

                        +   parameter  and  command  substitution
                            occurs,

                        +   (escaped) \NEWLINE is ignored, and

                        +   `\' must be used to quote the charac-
                            ters `\', `$', and ``'.

     The resulting document becomes the standard input.








     <&digit
          Use the file associated with file descriptor  digit  as
          standard  input.   Similarly  for  the  standard output
          using >&digit.

     <&-  The standard input is closed.  Similarly for the  stan-
          dard output using `>&-'.

     If any of the  above  is  preceded  by  a  digit,  the  file
     descriptor  which  will  be associated with the file is that
     specified by the digit (instead of the default 0 or 1).  For
     example:

          ... 2>&1

     associates file descriptor 2 with the file currently associ-
     ated with file descriptor 1.

     The order in which redirections are  specified  is  signifi-
     cant.   The shell evaluates redirections left-to-right.  For
     example:

          ... 1>xxx 2>&1

     first associates file descriptor 1 with file xxx.  It  asso-
     ciates  file descriptor 2 with the file associated with file
     descriptor 1 (namely, file xxx).  If the order  of  redirec-
     tions  were  reversed, file descriptor 2 would be associated
     with the terminal (assuming file descriptor 1 had been)  and
     file descriptor 1 would be associated with file xxx.

     Using the terminology introduced on the  first  page,  under
     Commands,  if  a  command is composed of several simple com-
     mands, redirection will be evaluated for the entire  command
     before  it  is  evaluated for each simple command.  That is,
     the shell evaluates redirection for the  entire  list,  then
     each pipeline within the list, then each command within each
     pipeline, then each list within each command.

     If a command is followed by & the default standard input for
     the  command  is  the  empty file /dev/null.  Otherwise, the
     environment for the execution of a command contains the file
     descriptors   of   the   invoking   shell   as  modified  by
     input/output specifications.

  Filename Generation
     Before a command is executed, each command word  is  scanned
     for the characters `*', `?', and `['.  If one of these char-
     acters appears the word is regarded as a pattern.  The  word
     is  replaced with alphabetically sorted filenames that match
     the pattern.  If no filename is found that matches the  pat-
     tern,  the word is left unchanged.  The character `.' at the
     start of a filename or immediately following a `/', as  well
     as the character `/' itself, must be matched explicitly.

          *    Matches any string, including the null string.
          ?    Matches any single character.
          [...]
               Matches any one of  the  enclosed  characters.   A
               pair  of  characters  separated by `-' matches any
               character lexically between the  pair,  inclusive.
               If  the first character following the opening [ is
               a ! any character not enclosed is matched.

  Quoting
     The following characters have a special meaning to the shell
     and cause termination of a word unless quoted:

          ;  &  (  )  |  ^  <  > NEWLINES*   SPACES*   TABS*

     A character may be quoted (made  to  stand  for  itself)  by
     preceding  it with a backslash (\) or inserting it between a
     pair of quote marks (''  or  "").   During  processing,  the
     shell may quote certain characters to prevent them from tak-
     ing on a special meaning.  Backslashes used to quote a  sin-
     gle  character  are removed from the word before the command
     is executed.  The pair  \NEWLINE  is  removed  from  a  word
     before command and parameter substitution.

     All characters enclosed between a pair of single quote marks
     (''),  except  a  single  quote,  are  quoted  by the shell.
     Backslash has no special meaning inside  a  pair  of  single
     quotes.   A single quote may be quoted inside a pair of dou-
     ble quote marks (for example, "'").

     Inside a pair of double quote marks (""), parameter and com-
     mand substitution occurs and the shell quotes the results to
     avoid blank interpretation and file name generation.  If  $*
     is within a pair of double quotes, the positional parameters
     are substituted and quoted, separated by quoted spaces  ("$1
     $2  ..."); however, if $@ is within a pair of double quotes,
     the  positional  parameters  are  substituted  and   quoted,
     separated by unquoted spaces ("$1" "$2" ... ).  \ quotes the
     characters \, `, ", and $.  The  pair  \NEWLINE  is  removed
     before  parameter  and command substitution.  If a backslash
     precedes characters other than \, `, ", $, and NEWLINE, then
     the backslash itself is quoted by the shell.

  Prompting
     When used interactively, the shell prompts with the value of
     PS1  before  reading  a command.  If at any time a RETURN is
     typed and further input is needed to complete a command, the
     secondary prompt (the value of PS2) is issued.

  Environment
     The environment (see environ(5V)) is a  list  of  name-value
     pairs  that is passed to an executed program in the same way
     as a normal argument list.  The  shell  interacts  with  the
     environment in several ways.  On invocation, the shell scans
     the environment and creates a parameter for each name found,
     giving it the corresponding value.  If the user modifies the
     value of any of these parameters or creates new  parameters,
     none of these affects the environment unless the export com-
     mand is used to bind the shell's parameter to  the  environ-
     ment  (see  also `set -a').  A parameter may be removed from
     the environment with the  unset  command.   The  environment
     seen by any executed command is thus composed of any unmodi-
     fied name-value pairs originally  inherited  by  the  shell,
     minus  any pairs removed by unset, plus any modifications or
     additions, all of which must be noted in export commands.

     The environment for any simple command may be  augmented  by
     prefixing  it  with  one  or more assignments to parameters.
     Thus:

          TERM=450cmd

     and

          (export TERM; TERM=450;cmd)

     are equivalent (as far as  the  execution  of  cmd  is  con-
     cerned).

     If the -k option is set, all keyword arguments are placed in
     the  environment, even if they occur after the command name.
     The following first prints a=b c and c:

          echo a=b c
          set -k
          echo a=b c

  Signals
     The INTERRUPT and QUIT signals for an  invoked  command  are
     ignored  if  the command is followed by &; otherwise signals
     have the values inherited by the shell from its parent  (but
     see  also  the  trap  command  below).  INTERRUPT is handled
     asynchronously.








  Execution
     Each time a command is executed, the above substitutions are
     carried out.  If the command name matches one of the Special
     Commands listed below, it is executed in the shell  process.
     If  the  command  name does not match a Special Command, but
     matches the name of a defined function, the function is exe-
     cuted  in  the shell process (note how this differs from the
     execution of shell procedures).  The  positional  parameters
     $1,  $2, ....  are set to the arguments of the function.  If
     the command name matches neither a Special Command  nor  the
     name  of a defined function, a new process is created and an
     attempt is made to execute the command using execve(2V).

     The shell parameter PATH defines the  search  path  for  the
     directory  containing  the  command.   Alternative directory
     names are separated by a colon (:).   The  default  path  is
     :/usr/ucb:/bin:/usr/bin   (specifying  /usr/ucb,  /bin,  and
     /usr/bin, in addition to  the  current  directory).   Direc-
     tories  are  searched  in  order.   The current directory is
     specified by a null path name, which can appear  immediately
     after  the  equal sign (PATH=:...), between the colon delim-
     iters (...::...) anywhere else in the path list, or  at  the
     end of the path list (...:).  If the command name contains a
     / the search path is not used.  Otherwise, each directory in
     the  path  is  searched for an executable file.  If the file
     has execute permission but is not an binary executable  (see
     a.out(5)  for details) or an executable script (with a first
     line beginning with #!) it is assumed to be a file  contain-
     ing shell commands, and a subshell is spawned to read it.  A
     parenthesized command is also executed in a subshell.

     The location in the search path where a command was found is
     remembered  by  the  shell  (to help avoid unnecessary execs
     later).  If the command was found in a  relative  directory,
     its  location  must  be  re-determined  whenever the current
     directory changes.  The shell forgets all  remembered  loca-
     tions whenever the PATH variable is changed or the `hash -r'
     command is executed (see below).

  Special Commands
     Input/output redirection is now  permitted  for  these  com-
     mands.  File descriptor 1 is the default output location.

     :              No effect; the command does nothing.  A  zero
                    exit code is returned.

     . filename     Read and execute commands from  filename  and
                    return.  The search path specified by PATH is
                    used  to  find   the   directory   containing
                    filename.

     break [ n ]    Exit from the enclosing for or while loop, if
                    any.  If n is specified break n levels.

     continue [ n ] Resume the next iteration  of  the  enclosing
                    for  or while loop.  If n is specified resume
                    at the n'th enclosing loop.

     cd[ arg ]      Change the  current  directory  to  argument.
                    The shell parameter HOME is the default argu-
                    ment.  The shell parameter CDPATH defines the
                    search  path  for  the  directory  containing
                    argument.  Alternative  directory  names  are
                    separated  by  a colon (:).  The default path
                    is NULL (specifying the  current  directory).
                    Note: the current directory is specified by a
                    null path name, which can appear  immediately
                    after  the  equal  sign  or between the colon
                    delimiters anywhere else in  the  path  list.
                    If  argument  begins with a / the search path
                    is not used.  Otherwise,  each  directory  in
                    the path is searched for argument.

     echo [ argument ... ]
                    Echo arguments. See echo(1V)  for  usage  and
                    description.

     eval [ argument ... ]
                    The arguments are read as input to the  shell
                    and the resulting command(s) executed.

     exec [ argument ... ]
                    The command specified  by  the  arguments  is
                    executed  in  place  of  this  shell  without
                    creating a new process.   Input/output  argu-
                    ments  may  appear and, if no other arguments
                    are given, modify the shell's input/output.

















     exit [ n ]     Exit a shell with the exit  status  specified
                    by  n.   If  n  is omitted the exit status is
                    that of the last  command  executed  (an  EOF
                    will also cause the shell to exit.)

     export [ name ... ]
                    The given  names  are  marked  for  automatic
                    export  to  the  environment of subsequently-
                    executed  commands.   If  no  arguments   are
                    given,  variable  names that have been marked
                    for export during the current shell's  execu-
                    tion  are  listed.   (Variable names exported
                    from a parent shell are listed only  if  they
                    have  been  exported again during the current
                    shell's execution.) Function  names  are  not
                    exported.

     getopts        Use in  shell  scripts  to  parse  positional
                    parameters  and check for legal options.  See
                    getopts(1) for usage and description.

     hash [ -r ] [ name ... ]
                    For each name, the  location  in  the  search
                    path  of  the  command  specified  by name is
                    determined and remembered by the shell.   The
                    -r  option  causes  the  shell  to forget all
                    remembered locations.  If  no  arguments  are
                    given,  information about remembered commands
                    is presented.  hits is the number of times  a
                    command  has  been  invoked by the shell pro-
                    cess.  cost is a measure of the work required
                    to locate a command in the search path.  If a
                    command is found in a "relative" directory in
                    the  search  path,  after  changing  to  that
                    directory, the stored location of  that  com-
                    mand  is  recalculated.   Commands  for which
                    this will be done are indicated by an  aster-
                    isk  (*)  adjacent  to  the hits information.
                    cost will be incremented when the  recalcula-
                    tion is done.

     login [ argument ... ]
                    Equivalent to `exec login  argument....'  See
                    login(1) for usage and description.

     newgrp [ argument ... ]
                    Equivalent to `exec newgrp argument....'  See
                    newgrp(1) for usage and description.

     pwd            Print the  current  working  directory.   See
                    pwd(1) for usage and description.

     read [ name ... ]
                    One line is read from the standard input and,
                    using the internal field separator, IFS (nor-
                    mally a SPACE or TAB character),  to  delimit
                    word  boundaries,  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.  Lines can be con-
                    tinued using \NEWLINE.  Characters other than
                    NEWLINE can be quoted by preceding them  with
                    a  backslash.   These backslashes are removed
                    before words are assigned to  names,  and  no
                    interpretation  is done on the character that
                    follows the backslash.  The return code is  0
                    unless an EOF is encountered.

     readonly [ name ... ]
                    The given names are marked readonly  and  the
                    values  of the these names may not be changed
                    by subsequent assignment.   If  no  arguments
                    are  given,  a  list of all readonly names is
                    printed.

     return [ n ]   Exit a function with the return value  speci-
                    fied  by  n.   If  n  is  omitted, the return
                    status is that of the last command executed.

     set [ -aefhkntuvx- [ argument ... ] ]

                    -a   Mark variables  which  are  modified  or
                         created for export.

                    -e   Exit immediately if a command exits with
                         a nonzero exit status.

                    -f   Disable filename generation.

                    -h   Locate and remember function commands as
                         functions are defined (function commands
                         are normally located when  the  function
                         is executed).

                    -k   All keyword arguments are placed in  the
                         environment  for  a  command,  not  just
                         those that precede the command name.

                    -n   Read commands but do not execute them.

                    -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.

                    -    Do not change any of the options; useful
                         in setting $1 to `-'.

                    Using `+' rather than  `-'  turns  off  these
                    options.  These options can also be used upon
                    invocation of the shell.  The current set  of
                    options  may be found in `$-'.  The remaining
                    arguments are positional parameters  and  are
                    assigned, in order, to $1, $2, and so on.  If
                    no arguments are given,  the  values  of  all
                    names are printed.

     shift [ n ]    The positional parameters are shifted to  the
                    left, from position n+1 to position 1, and so
                    on.  Previous values for $1  through  $n  are
                    discarded.   If n is not given, it is assumed
                    to be 1.

     test           Evaluate   conditional    expressions.    See
                    test(1V) for usage and description.

     times          Print the accumulated user and  system  times
                    for processes run from the shell.

     trap [ arg ] [ n ] ...
                    The command arg is to be  read  and  executed
                    when  the shell receives signal(s) n.  (Note:
                    arg is scanned once when the trap is set  and
                    once  when  the trap is taken.) Trap commands
                    are executed in order of signal number.   Any
                    attempt  to  set  a trap on a signal that was
                    ignored on entry  to  the  current  shell  is
                    ineffective.   If arg is absent all trap(s) n
                    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
                    n  is  0  the command arg is executed on exit
                    from the shell.  The  trap  command  with  no
                    arguments  prints  a list of commands associ-
                    ated with each signal number.

     type [ name ... ]
                    For each  name,  indicate  how  it  would  be
                    interpreted if used as a command name.

     umask [ ooo ]
                    The user file-creation mode mask  is  set  to
                    ooo  (see  csh(1)).   The  three octal digits
                    refer to read/write/execute  permissions  for
                    owner,  group, and others, respectively.  The
                    value of each specified digit  is  subtracted
                    from  the  corresponding "digit" specified by
                    the system for the creation of a  file.   For
                    example,  umask  022 removes group and others
                    write permission (files normally created with
                    mode  777 become mode 755; files created with
                    mode 666 become mode 644).  The current value
                    of the mask is printed if ooo is omitted.

     unset [ name ... ]
                    For each name, remove the corresponding vari-
                    able  or  function.  The variables PATH, PS1,
                    PS2, MAILCHECK and IFS cannot be unset.

     wait [ n ]     Wait for the background process whose process
                    ID  is  n  and report its termination status.
                    If n is omitted, all  the  shell's  currently
                    active  background  processes  are waited for
                    and the return code will be zero.

EXIT STATUS
     Errors detected by the shell, such as syntax errors,  return
     a  nonzero  exit  status.  If the shell is being used nonin-
     teractively execution of the shell file is abandoned.   Oth-
     erwise,  the  shell returns the exit status of the last com-
     mand executed (see also the exit command above).

ENVIRONMENT
     The environment variables  LC_CTYPE,  LANG,  and  LC_default
     control  the character classification throughout all command
     line parsing.  These variables are checked in the  following
     order:  LC_CTYPE,  LANG, and LC_default.  When a valid value
     is found,  remaining  environment  variables  for  character
     classification  are ignored.  For example, a new setting for
     LANG does not override the current valid character classifi-
     cation rules of LC_CTYPE.  When none of the values is valid,
     the shell character classification defaults to  the  POSIX.1
     "C" locale.

FILES
     /etc/profile
     $HOME/.profile
     /tmp/sh*
     /dev/null
     /usr/lib/rsh


SEE ALSO
     cd(1),  csh(1),  echo(1V),  env(1),  getopts(1),   login(1),
     newgrp(1),  pwd(1),  test(1V), wait(1), dup(2V), execve(2V),
     fork(2V),   pipe(2V),   sigvec(2),   wait(2V),    execl(3V),
     a.out(5), environ(5V), locale(5)

     Doing More with SunOS

WARNINGS
     Words used for filenames in input/output redirection are not
     interpreted  for  filename generation (see File Name Genera-
     tion, above).  For example, `cat file1 > a*' will  create  a
     file named `a*'.

     Because commands in pipelines are run as separate processes,
     variables  set  in  a  pipeline have no effect on the parent
     shell.

     If  you  get  the  error  message  `cannot  fork,  too  many
     processes',  try  using the wait(1) command to clean up your
     background processes.  If this does  not  help,  the  system
     process  table  is probably full or you have too many active
     foreground processes.  There is a limit  to  the  number  of
     process  IDs  associated  with your login, and to the number
     the system can keep track of.

BUGS
     If a command is executed, and a command with the  same  name
     is  installed  in  a directory in the search path before the
     directory where the original command was  found,  the  shell
     will  continue  to  exec the original command.  Use the hash
     command to correct this situation.

     If you move the current directory or one above it,  pwd  may
     not  give  the  correct response.  Use the cd command with a
     full path name to correct this situation.

     Not all the processes of a 3-  or  more-stage  pipeline  are
     children of the shell, and thus cannot be waited for.

     For wait n, if n is  not  an  active  process  ID,  all  the
     shell's currently active background processes are waited for
     and the return code will be zero.