unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (SunOS-4.1.3)
Page:
Section:
Apropos / Subsearch:
optional field

SH(1)                       General Commands Manual                      SH(1)



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 let-
       ters, 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 commands, and the  remaining  argu-
       ments  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 inter-
                      active.  In this case  TERMINATE  is  ignored  (so  that
                      `kill  0' does not kill an interactive shell) and INTER-
                      RUPT is caught and ignored (so that wait  is  interrupt-
                      ible).  In all cases, QUIT is ignored by the shell.

       -s             If  the  -s  option is present or if no arguments remain
                      commands are read from the standard input.  Any  remain-
                      ing  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  com-
       mand, under Special Commands, below.

USAGE
       Refer  to  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
       terminates  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 stan-
       dard  input  of  the  next  command.  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 pipelines, sepa-
       rated  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 precedence.  A semicolon (;) sequentially executes the  pre-
       ceding pipeline; an ampersand (&&) asynchronously executes the preceding
       pipeline (the shell does not wait for that pipeline  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 commands.

       A command is either a simple command or one of the following  construc-
       tions.   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  posi-
              tional 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  pat-
              tern that matches word.  The form of the patterns is the same as
              that used for  filename  generation  (see  Filename  Generation)
              except that a slash, a leading dot, or a dot immediately follow-
              ing 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.  Other-
              wise, the list following elif is executed 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 terminates.  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 NEW-
       LINE 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 characters 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 back-
       slash (\) and are removed before the command string is read.   Escaping
       grave  accents allows nested command substitution.  If the command sub-
       stitution lies within a pair of double quotes (" ...` ...`  ...  "),  a
       backslash  used  to  escape a double quote (\") will be removed; other-
       wise, it will be left intact.

       If a backslash is used to escape a NEWLINE character  (\NEWLINE),  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 \, `, ", NEWLINE, and $
       are left intact when the command string is read.

   Parameter Substitution
       The character $ is used to introduce substitutable  parameters.   There
       are two types of parameters, positional and keyword.  If parameter is a
       digit, it is a positional  parameter.   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 charac-
              ters).  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; other-
              wise 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; other-
              wise, 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 sub-
       stituted  string,  so  that,  in the following example, 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 synchronously exe-
                     cuted 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  Execution
                             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
                             message  that  will be printed when the modifica-
                             tion 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  environ-
                             ment (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 characters (those found in
       IFS) and split into distinct arguments where such characters are found.
       Explicit  null  arguments ("" or '') are retained.  Implicit null argu-
       ments (those  resulting  from  parameters  that  have  no  values)  are
       removed.

   Input/Output
       A command's input and output may be redirected using a special notation
       interpreted by the shell.  The following may appear anywhere in a  sim-
       ple 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.

       <&lt;word         Use file word as standard input (file descriptor 0).

       >&gt;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.

       >&gt;>&gt;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.

       <&lt;<&lt;[-]word     After parameter and command substitution is done on word,
                     the shell input is read up to the first line that  liter-
                     ally  matches the resulting word, or to an EOF.  If, how-
                     ever, `-' is appended to:

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

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

                            o   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 Quoting, later),
                     no additional processing is done to the shell input.   If
                     no characters of word are quoted:

                            o   parameter and command substitution occurs,

                            o   (escaped) \NEWLINE is ignored, and

                            o   `\'  must be used to quote the characters `\',
                                `$', and ``'.

       The resulting document becomes the standard input.

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

       <&lt;&&amp;-    The standard input is closed.  Similarly for the standard output
              using `>&gt;&&amp;-'.

       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  associated  with
       file descriptor 1.

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

              ... 1>xxx 2>&1

       first associates file descriptor 1 with file xxx.  It  associates  file
       descriptor  2  with the file associated with file descriptor 1 (namely,
       file xxx).  If the order of redirections 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 commands, 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 pipe-
       line, then each list within each command.

       If  a  command is followed by &&amp; the default standard input for the com-
       mand 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 characters appears the
       word is regarded as a pattern.  The word is  replaced  with  alphabeti-
       cally sorted filenames that match the pattern.  If no filename is found
       that matches the pattern, 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 lexi-
                     cally between the pair, inclusive.  If the first  charac-
                     ter  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:

              ;  &&amp;  (  )  |  ^  <&lt;  >&gt; NEWLINE   SPACE   TAB

       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 taking on a special  meaning.   Backslashes  used  to
       quote  a  single 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  spe-
       cial  meaning  inside  a  pair of single quotes.  A single quote may be
       quoted inside a pair of double quote marks (for example, "'").

       Inside a pair of double quote marks (""), parameter and command substi-
       tution occurs and the shell quotes the results to avoid blank interpre-
       tation 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 dou-
       ble quotes, the positional parameters are substituted and quoted, sepa-
       rated 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  modi-
       fies  the  value  of any of these parameters or creates new parameters,
       none of these affects the environment unless the export command is used
       to  bind  the shell's parameter to the environment (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
       unmodified 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 concerned).

       If  the -k option is set, all keyword arguments are placed in the envi-
       ronment, 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 &&amp;; otherwise signals have the values  inher-
       ited  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 func-
       tion, the function is executed in the shell process (note how this dif-
       fers  from  the execution of shell procedures).  The positional parame-
       ters $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 con-
       taining 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).
       Directories  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 delimiters (...::...) 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 direc-
       tory 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 containing shell commands, and a subshell is
       spawned to read it.  A parenthesized command is also executed in a sub-
       shell.

       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  remem-
       bered  locations 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  commands.   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 direc-
                      tory 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  argument.   The  shell
                      parameter  CDPATH defines the search path for the direc-
                      tory 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 arguments may appear and, if no other argu-
                      ments 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 execution
                      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  process.   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 loca-
                      tion  of  that  command  is  recalculated.  Commands for
                      which this will be done are indicated by an asterisk (*)
                      adjacent  to  the hits information.  cost will be incre-
                      mented when the recalculation 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 (normally 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  continued  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 interpreta-
                      tion is done on the character  that  follows  the  back-
                      slash.   The  return  code is 0 unless an EOF is encoun-
                      tered.

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

       return [ n ]   Exit  a  function  with the return value specified 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 func-
                             tions are defined (function commands are normally
                             located when the function is executed).

                      -k     All  keyword arguments are placed in the environ-
                             ment 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 substitut-
                             ing.

                      -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 set-
                             ting $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  pro-
                      cesses 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
                      associated 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 cur-
                      rent value of the mask is printed if ooo is omitted.

       unset [ name ... ]
                      For each name,  remove  the  corresponding  variable  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 noninteractively execution  of
       the  shell  file  is  abandoned.  Otherwise, the shell returns the exit
       status of the last command 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 vari-
       ables for character classification are ignored.   For  example,  a  new
       setting  for LANG does not override the current valid character classi-
       fication 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)

WARNINGS
       Words  used  for  filenames  in input/output redirection are not inter-
       preted for filename generation (see File Name Generation, above).   For
       example, `cat file1 >&gt; 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 origi-
       nal  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.



                                2 October 1989                           SH(1)