Bourne | Ash |  #!  | find | ARG_MAX | Shells | portability | permissions | UUOC | - | ../Various | HOME
"$@" | echo/printf | set -e | test | tty defs | tty chars | $() vs ) | IFS | using siginfo | nanosleep | line charset | locale

Manual of the System V Bourne Shell on Ultrix (sh5)

original sh5.1 massaged, nroffed and htmlized.

sh5(1)                                                                  sh5(1)

       sh5, rsh5 - shell, the standard/restricted command programming language

       sh5 [ -acefhiknrstuvx ] [ args ]
       rsh5 [ -acefhiknrstuvx ] [ args ]

       The sh5 program is a command line interpreter and programming  language
       that  executes  commands read from a terminal or a file.  The rsh5 pro-
       gram is a restricted version of the standard command  interpreter  sh5.
       It is used to set up login names and execution environments whose capa-
       bilities are more controlled than those of  the  standard  shell.   See
       Invocation  below for the meaning of arguments to the shell.  This ver-
       sion of the shell is from SYSTEM V  Rel  2.   For  further  information
       about the standard Version 7 shell interpreter, see sh(1).

       A  blank is a tab or a space.  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 !.

       A  simple-command is a sequence of non-blank 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.  For
       further information, see exec(2).  The value of a simple command is its
       exit status if it terminates normally, or (octal) 200+status if it ter-
       minates abnormally. For a list of status values, see signal(2).

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

       A list is a sequence of one or more pipelines 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 precedence.  A semicolon (;) causes
       sequential execution of  the  preceding  pipeline.   An  ampersand  (&)
       causes  asynchronous execution of the preceding pipeline.  That is, the
       shell does not wait for that pipeline to finish.  The  symbol  &&  (||)
       causes  the  list  following  it  to  be executed only if the preceding
       pipeline returns a zero (non-zero) exit status.  An arbitrary number of
       new-lines  may appear in a list, instead of semicolons, to delimit com-

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

       for name [ in word... ] do list done
              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.  The until command may be used in place of while to
              negate the loop termination test.
              Execute list in a sub-shell.
              Simply executes list from current shell.
       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.  For further information, see Exe-

       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 { }

       A word beginning with # causes that word and all the following  charac-
       ters up to a new-line to be ignored.

   Command Substitution
       The  standard output from a command enclosed in a pair of grave accents
       ( `command` ) may be used as part or all of a word.  Trailing new-lines
       are removed.

   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.

              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
              If parameter is set and is non-null, 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 example, pwd is  executed
       only if d is not set or is null:
       echo ${d:-`pwd`}

       If  the colon (:) is omitted from the above expressions, the shell only
       checks whether parameter is set or not.

       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
              ?      The  decimal  value  returned  by  the last synchronously
                     executed command.
              $      The process number of this shell.
              !      The  process  number  of  the  last  background   command

       The following parameters are used by the shell:
              HOME   The default argument (home directory) for the cd command.
              PATH   The search path for commands.  For  further  information,
                     see  Execution  below.   The  user may not change PATH if
                     executing under rsh5.
              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.
                     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 prompt.
                     A colon (:)  separated  list  of  file  names.   If  this
                     parameter  is  set,  the  shell  informs  the user of the
                     arrival of mail in any of the specified files.  Each file
                     name  can  be  followed  by  % and a message 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 new-
              SHELL  When the shell is invoked, it scans the  environment  for
                     this  name.  For  further  information,  see  Environment
                     below.  If it is found and there is an 'r'  in  the  file
                     name  part  of  its value, the shell becomes a restricted

       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
       arguments  (those  resulting  from  parameters that have no values) are

   File Name Generation
       Following substitution, 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  alphabetically  sorted  file
       names  that  match  the pattern.  If no file name is found that matches
       the pattern, the word is left unchanged.  The character .  at the start
       of a file name 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.

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

              ;  &  (  ) |  ^  <  >  new-line  space  tab

       A  character  may  be  quoted  (that  is,  made to stand for itself) by
       preceding it with a \.  The pair \new-line is ignored.  All  characters
       enclosed  between  a  pair of single quote marks (' '), except a single
       quote, are quoted.  Inside  double  quote  marks  (""),  parameter  and
       command substitution occurs and \ quotes the characters \, `, ", and $.
       "$*" is equivalent to "$1 $2 ...", whereas "$@" is equivalent  to  "$1"
       "$2" ....

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

       Before a command is executed, its input and output  may  be  redirected
       using  a  special 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.  Substitution occurs
       before word or digit is used:

       <word         Use file word as standard input (file descriptor 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 end-of-
                     file.  Otherwise, the file is created.
       <<[ - ]word   The shell input is read up to a line that is the same  as
                     word,  or  to  an  end-of-file.   The  resulting document
                     becomes the standard input.  If any character of word  is
                     quoted,  no  interpretation is placed upon the characters
                     of  the  document.   Otherwise,  parameter  and   command
                     substitution  occurs,  (unescaped)  \new-line is ignored,
                     and \ must be used to quote the characters \, $,  `,  and
                     the first character of word.  If - is appended to <<, all
                     leading  tabs  are  stripped  from  word  and  from   the
       <&digit       Use  the  file  associated  with file descriptor digit as
                     standard input.  Similarly for the standard output  using
       <&-           The standard input is closed.  Similarly for the standard
                     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:

       This 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:

       The first associates file descriptor 1 with file  xxx.   It  associates
       file descriptor 2 with the file associated with file descriptor 1 (that
       is, 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.

       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.

       Redirection of output is not allowed in the restricted shell.

       The  environment  is  a  list  of name-value pairs that is passed to an
       executed program in the same  way  as  a  normal  argument  list.   For
       further  information,  see  environ(5).   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 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=450 cmd
       (export TERM; TERM=450; cmd)

       These are equivalent (as far as the execution of cmd is concerned).

       If  the  -k  flag  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

       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, with the exception of signal
       11.  For further information, see also the trap command below.

       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 executed 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 via exec(2).

       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 :/bin:/usr/bin (specifying the current
       directory, /bin, and /usr/bin, in that order).  Note that  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 the command name contains a / the
       search path is not used.  Such commands will not  be  executed  by  the
       restricted  shell.   Otherwise,  each directory in the path is searched
       for an executable file.  If the file has execute permission but is  not
       an a.out file, it is assumed to be a file containing shell commands.  A
       sub-shell 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 exec 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  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
       . file Read and execute commands from file and return.  The search path
              specified by PATH is used to find the directory containing file.
       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 arg.  The shell  parameter  HOME
              is  the  default  arg.   The  shell parameter CDPATH defines the
              search path  for  the  directory  containing  arg.   Alternative
              directory  names are separated by a colon (:).  The default path
              is <null> (specifying the current  directory).   Note  that  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 arg begins with a
              / the search path is not used.  Otherwise, each directory in the
              path is searched for arg.  The cd command may not be executed by
       echo [ arg... ]
              Each  given  name  is  marked  for  automatic  export   to   the
              environment  of subsequently-executed commands.  If no arguments
              are given, a list of all names that are exported in  this  shell
              is printed.  Function names may not be exported.
       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.  There are  certain  situations  which  require  that  the
              stored  location  of  a  command  be recalculated.  Commands for
              which this will  be  done  are  indicated  by  an  asterisk  (*)
              adjacent to the hits information.  Cost will be incremented when
              the recalculation is done.
       newgrp [ arg... ]
              Equivalent to exec newgrp arg ....  For usage  and  description,
              see newgrp(1).
       pwd    Print the current working directory.  For usage and description,
              see pwd(1).
       read [ name... ]
              One line is read from the standard input and the first  word  is
              assigned  to the first name, the second word to the second name,
              etc., with leftover words assigned to the last name.  The return
              code is 0 unless an end-of-file 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 ]
              Causes  a function to exit with the return value specified by n.
              If n is omitted, the return status is that of the  last  command
       set [ --aefhkntuvx [ arg... ] ]
              -a     Mark  variables which are modified or created for export.
              -e     Exit immediately if a command exits with a non-zero  exit
              -f     Disable file name 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 flags; useful in setting $1 to

              from the shell.
       trap [ arg ] [ n... ]
              The command arg is to  be  read  and  executed  when  the  shell
              receives  signal(s)  n.   Note that 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.   An  attempt  to  trap on signal 11 (memory fault)
              produces an error.  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.
       ulimit [ -fp ] [ n ]
              imposes a size limit of n
              -f     imposes a size limit of n  blocks  on  files  written  by
                     child processes (files of any size may be read).  With no
                     argument, the current limit is printed.
              -p     changes the pipe size to n (UNIX/RT only).
              If no option is given, -f is assumed.
       umask [ nnn ]
              The  user  file-creation  mask  is  set  to  nnn.   For  further
              information, see umask(2).  If nnn is omitted, the current value
              of the mask is printed.
       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  specified  process  and  report  its  termination
              status.   If n is not given all currently active child processes
              are waited for and the return code is zero.

       If the shell is invoked through exec(2)  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 /bin/sh5.  The flags below are interpreted by the  shell  on
       invocation  only.  Note that unless the -c or -s flag is specified, the
       first argument is assumed to be the name of a file containing commands,
       and the remaining arguments are passed as positional parameters to that
       command file:

       -c string If the -c flag is present commands are read from string.
       -s        If the -s flag is present or if no arguments remain  commands
                 are  read  from  the standard input.  Any remaining arguments
                 specify the positional parameters.  Shell output (except  for
                 Special Commands) is written to file descriptor 2.
       -i        If  the  -i  flag is present or if the shell input and output
                 are attached to a terminal, this shell  is  interactive.   In
                 this  case TERMINATE is ignored (so that kill 0 does not kill
                 an interactive shell) and INTERRUPT is caught and ignored (so
                 that  wait  is interruptible).  In all cases, QUIT is ignored
                 by the shell.
       -r        If the -r flag is present the shell is a restricted shell.

       The remaining flags and arguments are described under the  set  command

   rsh5 Only
       The rsh5 shell is used to set up login names and execution environments
       whose capabilities are more  controlled  than  those  of  the  standard
       shell.   The  actions of rsh are identical to those of sh5, except that
       the following are disallowed:
              changing directory, see cd(1),
              setting the value of $PATH,
              specifying path or command names containing /,
              redirecting output (> and >>).

       The restrictions above are enforced after .profile is interpreted.

       When a command to be executed is found to be a  shell  procedure,  rsh5
       invokes sh5 to execute it.  Thus, it is possible to provide to the end-
       user shell procedures that  have  access  to  the  full  power  of  the
       standard shell, while imposing a limited menu of commands.  This scheme
       assumes that the end-user does not have write and  execute  permissions
       in the same directory.

       The  net  effect  of these rules is that the writer of the .profile has
       complete control over user  actions,  by  performing  guaranteed  setup
       actions  and leaving the user in an appropriate directory (probably not
       the login directory).

       The system administrator often sets up a directory  of  commands  (that
       is,  /usr/rbin ) that can be safely invoked by rsh5.  Some systems also
       provide a restricted editor red.

       Errors detected by the shell, such as syntax errors, cause the shell to
       return  a  non-zero  exit  status.   If  the  shell  is being used non-
       interactively 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).

       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.


       cd(1),   echo(1),  login(1),  newgrp(1),  printenv(1),  pwd(1),  sh(1),
       dup(2), exec(2),  fork(2),  pipe(2),  signal(2),  ulimit(2),  umask(2),
       a.out(5), profile(5), environ(5)