*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->OpenBSD man pages -> sh (1)              



NAME    [Toc]    [Back]

     sh - public domain Bourne shell

SYNOPSIS    [Toc]    [Back]

     sh [-+abCefhiklmnprsuvxX] [-+o option]
        [[-c command-string [command-name] | -s | file] [argument

DESCRIPTION    [Toc]    [Back]

     sh  is a reimplementation of the Bourne shell, a command interpreter for
     both interactive and script use.

   Shell startup    [Toc]    [Back]
     The following options can be specified only on  the  command

     -c command-string
             sh   will   execute   the  command(s)  contained  in

     -i      Interactive mode; see below.

     -l      Login shell; see below.

     -s      The shell reads commands from  standard  input;  all
non-option arguments
 are positional parameters.

     -r      Restricted mode; see below.

     In  addition  to the above, the options described in the set
built-in command
 can also be used on the command line.

     If neither the -c nor the -s option is specified, the  first
     argument  specifies  the name of a file the shell reads commands from.  If
     there are no non-option arguments, the shell reads  commands
from the
     standard  input.   The name of the shell (i.e., the contents
of $0) is determined
 as follows: if the -c option is used and there is a
     argument, it is used as the name; if commands are being read
from a file,
     the file is used as the name; otherwise, the name the  shell
was called
     with (i.e., argv[0]) is used.

     A  shell  is  ``interactive'' if the -i option is used or if
both standard
     input and standard error are attached to a tty.  An interactive shell has
     job  control  enabled  (if  available),  ignores the SIGINT,
     SIGTERM signals, and prints  prompts  before  reading  input
(see PS1 and PS2
     parameters).   For  non-interactive shells, the trackall option is on by
     default (see the set command below).

     A shell is ``restricted'' if the -r option is used or if either the basename
 of the name the shell was invoked with or the SHELL parameter match
     the pattern ``*r*sh'' (e.g., ``rsh'', ``rksh'',  ``rpdksh'',
etc.).  The
     following restrictions come into effect after the shell processes any
     profile and ENV files:

     +o   The cd command is disabled.
     +o   The SHELL, ENV, and PATH parameters cannot be changed.
     +o   Command names can't be specified with absolute or  relative paths.
     +o    The  -p option of the built-in command command can't be
     +o   Redirections that create files can't be used (i.e., `>',
`>|', `>>',

     A shell is ``privileged'' if the -p option is used or if the
real user ID
     or group ID does not match the effective user ID or group ID
     getuid(2)  and getgid(2)).  A privileged shell does not process
     $HOME/.profile nor the ENV parameter (see below).   Instead,
the file
     /etc/suid_profile is processed.  Clearing the privileged option causes
     the shell to set its effective user ID (group ID) to its real user ID
     (group ID).

     If  the basename of the name the shell is called with (i.e.,
     starts with `-' or if the -l option is used,  the  shell  is
assumed to be a
     login shell and the shell reads and executes the contents of
     and $HOME/.profile if they exist and are readable.

     If the ENV parameter is set when the shell  starts  (or,  in
the case of login
  shells, after any profiles are processed), its value is
subjected to
     parameter, command, arithmetic, and tilde (`~') substitution
and the resulting
  file (if any) is read and executed.  If the ENV parameter is not
     set (and not NULL) and  pdksh  was  compiled  with  the  DEFAULT_ENV macro defined,
  the  file named in that macro is included (after the
above mentioned
 substitutions have been performed).

     The exit status of the shell is  127  if  the  command  file
specified on the
     command  line  could  not  be opened, or non-zero if a fatal
syntax error occurred
 during the execution of a script.  In the absence  of
fatal errors,
     the exit status is that of the last command executed, or zero, if no command
 is executed.

   Command syntax    [Toc]    [Back]
     The shells begins parsing its  input  by  breaking  it  into
words.  Words,
     which are sequences of characters, are delimited by unquoted
     characters (space,  tab,  and  newline)  or  meta-characters
(`<', `>', `|',
     `;', `(', and `)').  Aside from delimiting words, spaces and
tabs are ignored,
 while newlines usually delimit commands.   The  metacharacters are
     used in building the following tokens: `<', `<&', `<<', `>',
`>&', `>>',
     etc. are used  to  specify  redirections  (see  Input/output
redirection below);
  `|' is used to create pipelines; `;' is used to separate commands;
     `&' is used to create asynchronous pipelines; `&&' and  `||'
are used to
     specify  conditional  execution; `;;' is used in case statements; and lastly,
 `( .. )' is used to create subshells.

     Whitespace and meta-characters can  be  quoted  individually
using a backslash
  (`'), or in groups using double (`"') or single (`'')
     Note that the following characters are also treated specially by the
     shell  and  must  be  quoted  if they are to represent themselves: `', `"',
     `'', `#', `$', ``', `~', `{', `}', `*', `?', and  `['.   The
first three of
     these  are  the  above  mentioned  quoting  characters  (see
Quoting below);
     `#', if used at the beginning of a word, introduces  a  comment -- everything
  after  the  `#' up to the nearest newline is ignored;
`$' is used to
     introduce parameter, command, and  arithmetic  substitutions
     Substitution  below);  ``'  introduces  an old-style command
     (see Substitution below); `~' begins a  directory  expansion
(see Tilde
     expansion  below);  `{'  and `}' delimit csh(1) style alterations (see Brace
     expansion below); and finally, `*', `?', and `[' are used in
file name
     generation (see File name patterns below).

     As  words  and tokens are parsed, the shell builds commands,
of which there
     are two basic  types:  simple-commands,  typically  programs
that are executed,
  and  compound-commands,  such as for and if statements,
grouping constructs,
 and function definitions.

     A simple-command consists of some combination  of  parameter
     (see   Parameters  below),  input/output  redirections  (see
     redirections below), and command words; the only restriction
is that parameter
 assignments come before any command words.  The command words, if
     any, define the command that is to be executed and its arguments.  The
     command  may  be  a shell built-in command, a function or an
external command
 (i.e., a separate executable file that is located using
the PATH parameter
  (see Command execution below)).  Note that all command constructs
     have an exit status: for external commands, this is  related
to the status
     returned  by wait(2) (if the command could not be found, the
exit status
     is 127; if it could not be  executed,  the  exit  status  is
126); the exit
     status of other command constructs (built-in commands, functions, compound-commands,
 pipelines, lists, etc.) are all well-defined
and are described
  where  the construct is described.  The exit status
of a command
     consisting only of parameter assignments is that of the last
command substitution
  performed during the parameter assignment or 0 is
there were no
     command substitutions.

     Commands can be chained together using the `|' token to form
     in which the standard output of each command but the last is
piped (see
     pipe(2)) to the standard input  of  the  following  command.
The exit status
     of  a  pipeline is that of its last command.  A pipeline may
be prefixed by
     the `!' reserved word, which causes the exit status  of  the
pipeline to be
     logically  complemented:  if  the original status was 0, the
     status will be 1; if the original status was not 0, the complemented status
 will be 0.

     Lists  of commands can be created by separating pipelines by
any of the
     following tokens: `&&', `||', `&', `|&', and `;'.  The first
two are for
     conditional  execution:  ``cmd1 && cmd2'' executes cmd2 only
if the exit
     status of cmd1 is zero; `||' is the opposite -- cmd2 is executed only if
     the  exit  status  of  cmd1 is non-zero.  `&&' and `||' have
equal precedence
     which is higher than that of `&', `|&', and `;', which  also
have equal
     precedence.   Note  that  the  `&&'  and  `||' operators are
  For example,  both  of  these  commands  will
print only "bar":

           false && echo foo || echo bar
           true || echo foo && echo bar

     The  `&'  token  causes the preceding command to be executed
     that is, the shell starts the command but does not wait  for
it to complete
  (the  shell  does  keep  track of the status of asynchronous commands,
     see Job control below).  When  an  asynchronous  command  is
started when job
     control  is disabled (i.e., in most scripts), the command is
started with
     signals SIGINT and SIGQUIT ignored and with input redirected
     /dev/null  (however,  redirections  specified  in  the asynchronous command
     have precedence).  Note that a command must follow the  `&&'
and `||' operators,
  while  it  need not follow `&', `|&', or `;'.  The
exit status of
     a list is that of the last command executed, with the exception of asynchronous
 lists, for which the exit status is 0.

     Compound  commands  are created using the following reserved
words.  These
     words are only recognized if they are unquoted and  if  they
are used as
     the first word of a command (i.e., they can't be preceded by
     assignments or redirections):

                case    else    function        !
                do      esac    if      until   [[
                done    fi      in      while   {
                elif    for     time    then    }

     Note: Some shells (but not this one) execute control  structure commands
     in a subshell when one or more of their file descriptors are
     so any environment changes inside  them  may  fail.   To  be
portable, the
     exec  statement  should be used instead to redirect file descriptors before
     the control structure.

     In the  following  compound  command  descriptions,  command
lists (denoted as
     list)  that  are  followed by reserved words must end with a
semicolon, a
     newline, or a (syntactically correct)  reserved  word.   For

            { echo foo; echo bar; }
            { echo foo; echo bar<newline> }
            { { echo foo; echo bar; } }

     are all valid, but

            { echo foo; echo bar }

     is not.

     ( list )
             Execute  list  in  a subshell.  There is no implicit
way to pass environment
 changes from a subshell back to  its  parent.

     { list }
             Compound  construct;  list is executed, but not in a
             Note that { and } are reserved words, not meta-characters.

     case  word  in  [[(] pattern [| pattern] ... ) list ;; ] ...
             The case statement attempts to  match  word  against
the specified
             patterns;  the  list  associated with the first successfully matched
             pattern is executed.  Patterns used in  case  statements are the
             same  as  those  used  for file name patterns except
that the restrictions
 regarding `.' and `/' are dropped.   Note
that any unquoted
 space before and after a pattern is stripped;
any space
             within a pattern must be quoted.  Both the word  and
the patterns
             are  subject  to  parameter, command, and arithmetic
             as well as tilde substitution.  For historical  reasons, open and
             close  braces  may  be  used  instead of in and esac
(e.g., case $foo
             { *) echo bar; }).  The exit status of a case statement is that
             of  the  executed  list; if no list is executed, the
exit status is

     for name [in word ... term] do list done
             For each word in the specified word list, the parameter name is
             set  to the word and list is executed.  If in is not
used to specify
 a word list, the positional parameters ($1,  $2,
etc.) are
             used  instead.   For  historical  reasons,  open and
close braces may
             be used instead of do and done (e.g., for i; {  echo
$i; }).  The
             exit status of a for statement is the last exit status of list;
             if list is never executed, the exit status is  zero.
term is either
 a newline or a `;'.

     if list then list [elif list then list] ... [else list] fi
             If  the  exit  status of the first list is zero, the
second list is
             executed; otherwise, the list following the elif, if
any, is executed
  with  similar consequences.  If all the lists
following the
             if and elifs fail (i.e., exit with non-zero status),
the list
             following  the else is executed.  The exit status of
an if statement
 is that of non-conditional list that is executed; if no nonconditional
 list is executed, the exit status is zero.

     until list do list done
             This works like while, except that the body is  executed only
             while the exit status of the first list is non-zero.

     while list do list done
             A while is a pre-checked loop.  Its body is executed
as often as
             the exit status of the first list is zero.  The exit
status of a
             while statement is the last exit status of the  list
in the body
             of  the  loop; if the body is not executed, the exit
status is zero.

     function name { list }
             Defines the function  name  (see  Functions  below).
Note that redirections
  specified  after a function definition are
             whenever the function  is  executed,  not  when  the
function definition
 is executed.

     name () command
             Mostly the same as function (see Functions below).

   Quoting    [Toc]    [Back]
     Quoting  is  used to prevent the shell from treating characters or words
     specially.  There are three methods of quoting.   First,  `'
quotes the
     following  character,  unless it is at the end of a line, in
which case
     both the `' and the newline are stripped.  Second, a  single
quote (`'')
     quotes everything up to the next single quote (this may span
     Third, a double quote (`"') quotes  all  characters,  except
`$', ``' and
     `',  up  to the next unquoted double quote.  `$' and ``' inside double
     quotes have their usual meaning (i.e., parameter, command or
     substitution)  except  no  field splitting is carried out on
the results of
     double-quoted substitutions.  If a `' inside a double-quoted
string is
     followed by `', `$', ``', or `"', it is replaced by the second character;
 if it is followed by a newline, both  the  `'  and  the
newline are
     stripped; otherwise, both the `' and the character following
are unchanged.

     Note: See POSIX mode below for a special rule regarding  sequences of the
     form "...`...

   Aliases    [Toc]    [Back]
     There  are  two types of aliases: normal command aliases and
tracked aliases.
  Command aliases are normally used as a short hand for a
long or often
  used command.  The shell expands command aliases (i.e.,
     the alias name for its value) when it reads the  first  word
of a command.
     An expanded alias is re-processed to check for more aliases.
If a command
 alias ends in a space or tab, the following word is also checked for
     alias  expansion.   The alias expansion process stops when a
word that is
     not an alias is found, when a quoted word is found  or  when
an alias word
     that is currently being expanded is found.

     The  following  command aliases are defined automatically by
the shell:

           hash='alias -t'
           type='whence -v'

     Tracked aliases allow the shell to remember where it found a
     command.   The first time the shell does a path search for a
command that
     is marked as a tracked alias, it saves the full path of  the
command.  The
     next  time  the  command  is  executed, the shell checks the
saved path to see
     that it is still valid, and if so, avoids repeating the path
     Tracked  aliases  can  be listed and created using alias -t.
Note that
     changing the PATH parameter clears the saved paths  for  all
tracked aliases.
  If the trackall option is set (i.e., set -o trackall or
set -h), the
     shell tracks all commands.  This option is set automatically
for non-interactive
  shells.  For interactive shells, only the following commands
     are automatically tracked: cat, cc,  chmod,  cp,  date,  ed,
emacs, grep, ls,
     mail, make, mv, pr, rm, sed, sh, vi, and who.

   Substitution    [Toc]    [Back]
     The first step the shell takes in executing a simple-command
is to perform
 substitutions on the words of the command.   There  are
three kinds of
     substitution: parameter, command, and arithmetic.  Parameter
 which are described in detail in  the  next  section,
take the form
     $name   or  ${...};  command  substitutions  take  the  form
$(command) or
     `command`;  and  arithmetic  substitutions  take  the   form

     If  a substitution appears outside of double quotes, the results of the
     substitution are generally subject to word or  field  splitting according
     to  the current value of the IFS parameter.  The IFS parameter specifies a
     list of characters which are used to break a string up  into
     words;  any  characters from the set space, tab, and newline
that appear in
     the IFS characters are called ``IFS whitespace''.  Sequences
of one or
     more  IFS whitespace characters, in combination with zero or
one non-IFS
     whitespace characters, delimit a field.  As a special  case,
leading and
     trailing  IFS  whitespace  is  stripped (i.e., no leading or
trailing empty
     field is created by it); leading or trailing non-IFS whitespace does create
 an empty field.

     Example: If IFS is set to ``<space>:'', and VAR is set to
     ``<space>A<space>:<space><space>B::D'', the substitution for
$VAR results
     in four fields: `A', `B', `,' and `D'.  Note that if the IFS
parameter is
     set  to  the NULL string, no field splitting is done; if the
parameter is
     unset, the default value of space, tab, and newline is used.

     Also,  note that the field splitting applies only to the immediate result
     of the substitution.  Using the previous example,  the  substitution for
     $VAR:E  results  in  the  fields:  ``A'',  ``B'',  ``'', and
``D:E'', not ``A'',
     ``B'', ``'', and ``E''.  This behavior is  POSIX  compliant,
but incompatible
  with  some  other  shell implementations which do field
splitting on the
     word which contained the substitution or use IFS as a general whitespace

     The results of substitution are, unless otherwise specified,
also subject
     to brace expansion and file name expansion (see the relevant
sections below).

     A  command  substitution is replaced by the output generated
by the specified
 command, which is run in a  subshell.   For  $(command)
     normal quoting rules are used when command is parsed; however, for the
     `command` form, a `' followed by any of `$', ``', or  `'  is
stripped (a
     `' followed by any other character is unchanged).  As a special case in
     command substitutions, a command of the form < file  is  interpreted to
     mean substitute the contents of file (note that $(< foo) has
the same effect
 as $(cat foo), but it is carried out  more  efficiently
because no
     process is started).

     Note: $(command) expressions are currently parsed by finding
the matching
     parenthesis, regardless of quoting.  This  should  be  fixed

     Arithmetic  substitutions  are  replaced by the value of the
specified expression.
  For example, the command echo  $((2+3*4))  prints
14.  See
     Arithmetic expressions for a description of an expression.

   Parameters    [Toc]    [Back]
     Parameters  are shell variables; they can be assigned values
and their
     values can be accessed using a  parameter  substitution.   A
parameter name
     is  either  one  of  the special single punctuation or digit
character parameters
 described below, or a letter followed by zero or  more
letters or
     digits  (`_'  counts  as a letter).  Parameter substitutions
take the form
     $name or ${name}, where name is a parameter name.   If  substitution is
     performed  on  a parameter that is not set, a null string is
     unless the nounset option (set -o nounset or set -u) is set,
in which
     case an error occurs.

     Parameters  can  be  assigned  values  in  a number of ways.
First, the shell
     implicitly sets some parameters like #, PWD, etc.;  this  is
the only way
     the  special  single  character parameters are set.  Second,
parameters are
     imported from the shell's environment  at  startup.   Third,
parameters can
     be assigned values on the command line, for example, FOO=bar
sets the parameter
 FOO to ``bar''; multiple parameter  assignments  can
be given on a
     single  command  line  and they can be followed by a simplecommand, in
     which case the assignments are in effect only for the  duration of the
     command  (such  assignments are also exported, see below for
     of this).  Note that both the parameter  name  and  the  `='
must be unquoted
     for  the  shell  to  recognize  a parameter assignment.  The
fourth way of
     setting a parameter is with the export, readonly and typeset
     see  their  descriptions  in  the Command execution section.
Fifth, for
     loops set parameters as well as the getopts, read and set -A
     Lastly,  parameters  can be assigned values using assignment
operators inside
 arithmetic expressions (see Arithmetic expressions  below) or using
     the  ${name=value}  form  of the parameter substitution (see

     Parameters with the export attribute (set using  the  export
or typeset -x
     commands,  or  by  parameter  assignments followed by simple
commands) are
     put in the environment (see environ(7)) of commands  run  by
the shell as
     name=value  pairs.   The order in which parameters appear in
the environment
 of a command is unspecified.  When the shell starts up,
it extracts
     parameters  and  their values from its environment and automatically sets
     the export attribute for those parameters.

     Modifiers can be applied to the ${name}  form  of  parameter

             If name is set and not NULL, it is substituted; otherwise, word
             is substituted.

             If name is set and not NULL,  word  is  substituted;
             nothing is substituted.

             If name is set and not NULL, it is substituted; otherwise, it is
             assigned word and the resulting  value  of  name  is

             If name is set and not NULL, it is substituted; otherwise, word
             is printed on standard error (preceded by name:) and
an error occurs
   (normally  causing  termination  of  a  shell
script, function or
             .-script).  If word is omitted the string  ``parameter null or not
             set'' is used instead.

     In  the  above  modifiers,  the `:' can be omitted, in which
case the conditions
 only depend on name being set (as opposed to  set  and
not NULL).  If
     word  is  needed,  parameter, command, arithmetic, and tilde
     are performed on it; if word is not needed, it is not evaluated.

     The  following  forms  of parameter substitution can also be

             The number of positional parameters if name is  `*',
`@', not
             specified,  or the length of the string value of parameter name.

     ${#name[*]}, ${#name[@]}
             The number of elements in the array name.

     ${name#pattern}, ${name##pattern}
             If pattern matches the beginning of the value of parameter name,
             the  matched text is deleted from the result of substitution.  A
             single `#' results in the shortest match, and two of
them result
             in the longest match.

     ${name%pattern}, ${name%%pattern}
             Like  ${..#..} substitution, but it deletes from the
end of the

     The following special parameters are implicitly set  by  the
shell and cannot
 be set directly using assignments:

     !         Process ID of the last background process started.
If no background
 processes have been started,  the  parameter
is not set.

     #         The number of positional parameters (i.e., $1, $2,

     $        The process ID of the shell,  or  the  PID  of  the
original shell if
              it  is  a  subshell.  Do NOT use this mechanism for
generating temporary
 file names; see mktemp(1) instead.

     -        The concatenation of the current single letter  options (see the
              set command below for a list of options).

     ?         The  exit status of the last non-asynchronous command executed.
              If the last command was killed by a signal,  $?  is
set to 128
              plus the signal number.

     0          The  name  the  shell  was  invoked  with  (i.e.,
argv[0]), or the
              command-name if it was invoked with the  -c  option
and the
              command-name was supplied, or the file argument, if
it was supplied.
  If the posix option is not set, $0  is  the
name of the
              current function or script.

     1 ... 9  The first nine positional parameters that were supplied to the
              shell, function or  .-script.   Further  positional
parameters may
              be accessed using ${number}.

     *         All  positional  parameters  (except parameter 0);
i.e., $1, $2,
              $3, ...  If used outside of double quotes,  parameters are separate
 words (which are subjected to word splitting);
if used
              within double quotes, parameters are  separated  by
the first
              character of the IFS parameter (or the empty string
if IFS is

     @        Same as $*, unless it is used inside double quotes,
in which
              case  a  separate  word is generated for each positional parameter.
              If there are no positional parameters, no  word  is
generated.  $@
              can  be used to access arguments, verbatim, without
losing NULL
              arguments or splitting arguments with spaces.

     The following parameters are set and/or used by the shell:

     CDPATH     Search path for the cd built-in  command.   Works
the same way
                as  PATH for those directories not beginning with
`/' in cd
                commands.  Note that if CDPATH is  set  and  does
not contain
                ``.''  or contains an empty path, the current directory is not
                searched.  Also, the  cd  built-in  command  will
display the resulting
  directory  when  a match is found in any
search path
                other than the empty path.

     COLUMNS    Set to the number of columns on the  terminal  or
window.  Currently
  set  to the ``cols'' value as reported by
stty(1) if
                that value is non-zero.  This parameter  is  used
by the set -o
                and   kill  -l  commands  to  format  information

     ENV        If this parameter is found to be  set  after  any
profile files
                are  executed,  the  expanded  value is used as a
shell startup
                file.  It typically contains function  and  alias

     ERRNO       Integer value of the shell's errno variable.  It
indicates the
                reason the last system call failed.  Not yet  implemented.

     EXECSHELL   If set, this parameter is assumed to contain the
shell that is
                to be used to  execute  commands  that  execve(2)
fails to execute
                and  which  do  not  start with a ``#!shell'' sequence.

     FCEDIT     The editor used by the fc command (see below).

     FPATH      Like PATH, but used when an undefined function is
executed to
                locate the file defining the function.  It is also searched
                when a command can't be found  using  PATH.   See
Functions below
                for more information.

     HOME        The default directory for the cd command and the
value substituted
 for an unqualified ~ (see  Tilde  expansion

     IFS         Internal  field separator, used during substitution and by the
                read command, to split values into distinct arguments; normally
   set   to   space,   tab  and  newline.   See
Substitution above for

                Note: This parameter is not imported from the environment when
                the shell is started.

                The version of shell and the date the version was

     LINENO     The line number of the function or  shell  script
that is currently
 being executed.

     LINES       Set  to  the  number of lines on the terminal or
window.  Not yet

     OLDPWD     The previous working directory.  Unset if cd  has
not successfully
  changed directories since the shell started, or if the
                shell doesn't know where it is.

     OPTARG     When using getopts, it contains the argument  for
a parsed option,
 if it requires one.

     OPTIND     The index of the last argument processed when using getopts.
                Assigning 1 to this parameter causes  getopts  to
process arguments
  from the beginning the next time it is invoked.

     PATH       A colon separated list of  directories  that  are
searched when
                looking  for  commands  and  .'d files.  An empty
string resulting
                from a leading or trailing colon, or two adjacent
colons, is
                treated as a ``.'', the current directory.

                If set, this parameter causes the posix option to
be enabled.
                See POSIX mode below.

     PPID       The process ID of the shell's parent (read-only).

     PS1         The prompt is printed verbatim (i.e., no substitutions are
                done).  Default is ``$ '' for non-root users, ``#
'' for root.

     PS2         Secondary prompt string, by default ``> '', used
when more input
 is needed to complete a command.

     PS4        Used to prefix commands that are  printed  during
                tracing  (see  the  set  -x  command below).  The
prompt is printed
                verbatim (i.e., no substitutions are done).   Default is
                ``+ ''.

     PWD         The  current working directory.  May be unset or
NULL if the
                shell doesn't know where it is.

     REPLY      Default parameter for  the  read  command  if  no
names are given.

     TMPDIR      The  directory shell temporary files are created
in.  If this
                parameter is not set, or does not contain the absolute path of
                a writable directory, temporary files are created
in /tmp.

   Tilde expansion    [Toc]    [Back]
     Tilde expansion, which is done in  parallel  with  parameter
     is done on words starting with an unquoted `~'.  The characters following
     the tilde, up to the first `/', if any, are assumed to be  a
login name.
     If  the  login  name  is empty, `+' or `-', the value of the
     OLDPWD parameter is substituted,  respectively.   Otherwise,
the password
     file  is  searched for the login name, and the tilde expression is substituted
 with the user's home directory.  If the login name  is
not found in
     the  password  file or if any quoting or parameter substitution occurs in
     the login name, no substitution is performed.

     In parameter assignments (those preceding  a  simple-command
or those occurring
  in  the  arguments  of alias, export, readonly, and
typeset), tilde
     expansion is done after any unquoted colon (`:'), and  login
names are also
 delimited by colons.

     The  home  directory  of previously expanded login names are
cached and reused.
  The alias -d command may be used to list, change, and
add to this
     cache   (e.g.,   alias   -d   fac=/usr/local/facilities;  cd

   File name patterns    [Toc]    [Back]
     A file name pattern is a word containing one or more unquoted `?' or `*'
     characters  or ``[..]'' sequences.  Once brace expansion has
been performed,
 the shell replaces file name patterns with the sorted names of
     all the files that match the pattern (if no files match, the
word is left
     unchanged).  The pattern elements have the  following  meaning:

     ?       Matches any single character.

     *       Matches any sequence of characters.

     [..]     Matches  any of the characters inside the brackets.
Ranges of
             characters can be specified by separating two  characters by a `-'
             (e.g.,  ``[a0-9]''  matches  the letter ``a'' or any
digit).  In order
 to represent itself, a `-' must either be quoted
or the first
             or last character in the character list.  Similarly,
a `]' must
             be quoted or the first character in the list  if  it
is to represent
 itself instead of the end of the list.  Also, a
`!' appearing
 at the start of the  list  has  special  meaning
(see below), so
             to represent itself it must be quoted or appear later in the

     [!..]   Like [..], except it matches any character  not  inside the brackets.
   Matches any string of characters that matches
zero or more
             occurrences of the specified patterns.  Example: The
             *(foo|bar)   matches   the  strings  ``'',  ``foo'',
             ``foobarfoo'', etc.

     +(pattern| ... |pattern)
             Matches any string of characters that matches one or
more occurrences
 of the specified patterns.  Example: The pattern
             +(foo|bar) matches  the  strings  ``foo'',  ``bar'',
``foobar'', etc.

     ?(pattern| ... |pattern)
             Matches  the  empty  string or a string that matches
one of the
             specified patterns.  Example: The pattern ?(foo|bar)
only matches
             the strings ``'', ``foo'' and ``bar''.

     @(pattern| ... |pattern)
             Matches  a  string that matches one of the specified
patterns.  Example:
  The  pattern  @(foo|bar)  only  matches  the
strings ``foo''
             and ``bar''.

     !(pattern| ... |pattern)
             Matches  any  string  that does not match one of the
specified patterns.
  Examples: The pattern !(foo|bar) matches all
strings except
  ``foo''  and ``bar''; the pattern !(*) matches
no strings;
             the pattern !(?)* matches all strings  (think  about

     Note  that  pdksh  currently never matches ``.'' and ``..'',
but the original
 ksh, Bourne sh and bash do, so this may have  to  change
(too bad).

     Note  that none of the above pattern elements match either a
period (`.')
     at the start of a file name or a slash (`/'), even  if  they
are explicitly
     used  in  a  [..] sequence; also, the names ``.'' and ``..''
are never
     matched, even by the pattern ``.*''.

     If the markdirs option is set, any directories  that  result
from file name
     generation are marked with a trailing `/'.

     The  POSIX  character classes (i.e., [:class-name:] inside a
[..] expression)
 are not yet implemented.

   Input/output redirection
     When a command is executed,  its  standard  input,  standard
output, and
     standard  error (file descriptors 0, 1, and 2, respectively)
are normally
     inherited from the shell.  Three exceptions to this are commands in
     pipelines,  for  which standard input and/or standard output
are those set
     up by the pipeline, asynchronous commands created  when  job
control is
     disabled,  for  which  standard input is initially set to be
from /dev/null,
     and commands for which any  of  the  following  redirections
have been specified:

     > file  Standard output is redirected to file.  If file does
not exist,
             it is created; if it does exist, is a  regular  file
and the
             noclobber option is set, an error occurs; otherwise,
the file is
             truncated.  Note that this means the command  cmd  <
foo > foo will
             open  foo  for  reading and then truncate it when it
opens it for
             writing, before cmd gets a chance to  actually  read

     >| file
             Same as >, except the file is truncated, even if the
             option is set.

     >> file
             Same as >, except if file exists it is  appended  to
instead of being
  truncated.   Also, the file is opened in append
mode, so
             writes always  go  to  the  end  of  the  file  (see

     <  file   Standard  input  is redirected from file, which is
opened for reading.

     <> file
             Same as <, except the file is opened for reading and

     << marker
             After  reading the command line containing this kind
of redirection
 (called a ``here document''), the shell  copies
lines from
             the  command  source  into  a temporary file until a
line matching
             marker is read.  When the command is executed, standard input is
             redirected  from the temporary file.  If marker contains no quoted
             characters, the contents of the temporary  file  are
processed as
             if  enclosed  in double quotes each time the command
is executed,
             so parameter, command, and arithmetic  substitutions
are performed,
  along  with backslash (`') escapes for `$',
``', `', and
             `0wline'.  If multiple here documents  are  used  on
the same command
 line, they are saved in order.

     <<- marker
             Same  as  <<,  except leading tabs are stripped from
lines in the
             here document.

     <& fd   Standard input is duplicated  from  file  descriptor
fd.  fd can be
             a single digit, indicating the number of an existing
file descriptor;
 the letter `p', indicating  the  file  descriptor associated
  with  the output of the current co-process; or
the character
             `-', indicating standard input is to be closed.

     >& fd   Same as <&, except the operation is done on standard

     In  any  of the above redirections, the file descriptor that
is redirected
     (i.e., standard input or standard output) can be  explicitly
given by preceding
 the redirection with a single digit.  Parameter, command, and
     arithmetic substitutions, tilde substitutions, and  (if  the
shell is interactive)
  file  name  generation  are all performed on the
file, marker and
     fd arguments of redirections.  Note, however, that  the  results of any
     file  name  generation  are  only  used  if a single file is
matched; if multiple
 files match, the word with the expanded file name generation characters
  is used.  Note that in restricted shells, redirections
which can
     create files cannot be used.

     For simple-commands, redirections may appear anywhere in the
command; for
     compound-commands  (if  statements,  etc.), any redirections
must appear at
     the end.  Redirections are  processed  after  pipelines  are
created and in
     the order they are given, so

     cat /foo/bar 2>&1 > /dev/null | cat -n

     will print an error with a line number prepended to it.

   Arithmetic expressions    [Toc]    [Back]
     Integer arithmetic expressions can be used with the let command, inside
     $((..))  expressions,   inside   array   references   (e.g.,
name[expr]), as numeric
  arguments to the test command, and as the value of an
assignment to
     an integer parameter.

     Expressions may contain alpha-numeric parameter identifiers,
array references,
  and  integer  constants and may be combined with the
following C operators
 (listed and grouped in increasing  order  of  precedence):

     Unary operators:
           + - ! ~ ++ --

     Binary operators:
           = *= /= %= += -= <<= >>= &= ^= |=
           == !=
           < <= >= >
           << >>
           + -
           * / %

     Ternary operators:
           ?: (precedence is immediately higher than assignment)

     Grouping operators:
           ( )

     Integer  constants may be specified with arbitrary bases using the notation
 base#number, where base is a decimal integer specifying
the base,
     and number is a number in the specified base.

     The operators are evaluated as follows:

           unary +
                   Result is the argument (included for completeness).

           unary -

           !       Logical NOT; the result is 1  if  argument  is
zero, 0 if not.

           ~       Arithmetic (bit-wise) NOT.

           ++      Increment; must be applied to a parameter (not
a literal or
                   other expression).  The  parameter  is  incremented by 1.
                   When  used as a prefix operator, the result is
the incremented
 value of the parameter; when used as  a
postfix operator,
  the result is the original value of the

           --      Similar to ++, except the parameter is  decremented by 1.

           ,        Separates  two  arithmetic  expressions;  the
left-hand side is
                   evaluated first, then the right.   The  result
is the value
                   of the expression on the right-hand side.

           =       Assignment; variable on the left is set to the
value on the

           *= /= += -= <<= >>= &= ^= |=
                   Assignment operators.   <var> <op> = <expr> is
the same as
                   <var> = <var> <op> ( <expr> ).

           ||      Logical OR; the result is 1 if either argument
is non-zero,
                   0 if not.  The right argument is evaluated only if the left
                   argument is zero.

           &&      Logical AND; the result is 1 if both arguments
are non-zero,
 0 if not.  The right argument is evaluated
only if the
                   left argument is non-zero.

           |       Arithmetic (bit-wise) OR.

           ^       Arithmetic (bit-wise) XOR (exclusive-OR).

           &       Arithmetic (bit-wise) AND.

           ==       Equal;  the result is 1 if both arguments are
equal, 0 if

           !=      Not equal; the result is 0 if  both  arguments
are equal, 1
                   if not.

           <        Less  than; the result is 1 if the left argument is less
                   than the right, 0 if not.

           <= >= >
                   Less than or equal,  greater  than  or  equal,
greater than.
                   See <.

           << >>   Shift left (right); the result is the left argument with
                   its bits shifted left (right)  by  the  amount
given in the
                   right argument.

           + - * /
                   Addition, subtraction, multiplication, and division.

           %       Remainder; the result is the remainder of  the
division of
                   the  left  argument by the right.  The sign of
the result is
                   unspecified if either argument is negative.

           <arg1> ? <arg2> : <arg3>
                   If  <arg1> is non-zero, the result is  <arg2>,

   Functions    [Toc]    [Back]
     Functions  are defined using either Korn shell function name
syntax or the
     Bourne/POSIX shell name() syntax (see below for the  difference between
     the  two  forms).  Functions are like .-scripts in that they
are executed
     in the  current  environment.   However,  unlike  .-scripts,
shell arguments
     (i.e., positional parameters $1, $2, etc.) are never visible
inside them.
     When the shell is determining the  location  of  a  command,
functions are
     searched after special built-in commands, before regular and
     built-ins, and before the PATH is searched.

     An  existing  function  may  be  deleted  using   unset   -f
function-name.  A list
     of  functions can be obtained using typeset +f and the function definitions
 can be listed using typeset -f.  The autoload  command
(which is an
     alias for typeset -fu) may be used to create undefined functions; when an
     undefined function is executed, the shell searches the  path
specified in
     the  FPATH  parameter  for  a file with the same name as the
function, which,
     if found, is read and executed.  If after executing the file
the named
     function  is  found to be defined, the function is executed;
otherwise, the
     normal command search is continued (i.e., the shell searches
the regular
     built-in command table and PATH).  Note that if a command is
not found
     using PATH, an attempt is made to autoload a function  using
FPATH (this
     is an undocumented feature of the original Korn shell).

     Functions can have two attributes, ``trace'' and ``export'',
which can be
     set with typeset -ft and typeset -fx, respectively.  When  a
traced function
 is executed, the shell's xtrace option is turned on for
the function's
 duration; otherwise, the xtrace option is turned off.
     ``export'' attribute of functions is currently not used.  In
the original
     Korn shell, exported functions are visible to shell  scripts
that are executed.

     Since  functions  are executed in the current shell environment, parameter
     assignments made inside  functions  are  visible  after  the
function completes.
  If this is not the desired effect, the typeset command can be
     used inside a function to create a  local  parameter.   Note
that special
     parameters (e.g., $$, $!) can't be scoped in this way.

     The  exit  status  of a function is that of the last command
executed in the
     function.  A function can be made to finish immediately  using the return
     command; this may also be used to explicitly specify the exit status.

     Functions defined with the function reserved word are treated differently
     in the following ways from functions defined with the () notation:

     +o   The $0 parameter is set to  the  name  of  the  function
         functions leave $0 untouched).

     +o    Parameter  assignments preceding function calls are not
kept in the
         shell environment (executing Bourne-style functions will
keep assignments).

     +o    OPTIND  is  saved/reset  and restored on entry and exit
from the function
 so getopts can be used  properly  both  inside  and
outside the
         function (Bourne-style functions leave OPTIND untouched,
so using
         getopts inside a function interferes with using  getopts
outside the
         function).   In  the  future,  the following differences
will also be

               +o   A separate  trap/signal  environment  will  be
used during the
                   execution  of  functions.  This will mean that
traps set inside
 a function will not  affect  the  shell's
traps and signals
  that  are  not ignored in the shell (but
may be trapped)
                   will have their default effect in a  function.

               +o    The  EXIT trap, if set in a function, will be
executed after
                   the function returns.

   POSIX mode    [Toc]    [Back]
     The shell is intended to be  POSIX  compliant;  however,  in
some cases,
     POSIX  behaviour  is  contrary  either  to the original Korn
shell behaviour
     or to user convenience.  How the shell behaves in these cases is determined
  by  the state of the posix option (set -o posix).  If
it is on, the
     POSIX behaviour is followed;  otherwise,  it  is  not.   The
posix option is
     set  automatically  when the shell starts up if the environment contains
     the POSIXLY_CORRECT parameter. (The shell can also  be  compiled so that it
     is  in  POSIX  mode by default; however, this is usually not

     The following is a list of things that are affected  by  the
state of the
     posix option:

     +o    Reading of $ENV.  If not in posix mode, the ENV parameter is not expanded
 and included when the shell starts.

     +o   Occurrences of
         In POSIX mode, the
         in non-POSIX mode, the backslash is stripped before  the
command substitution
 is interpreted.  For example, echo "`echo
         ``"hi"''  in  POSIX  mode, ``hi'' in non-POSIX mode.  To
avoid problems,
         use the $(...) form of command substitution.

     +o   kill -l output.  In POSIX mode, signal names are  listed
one per line;
         in  non-POSIX  mode, signal numbers, names, and descriptions are printed
 in columns.  In future, a  new  option  (-v  perhaps)
will be added to
         distinguish the two behaviours.

     +o    fg exit status.  In POSIX mode, the exit status is 0 if
no errors occur;
 in non-POSIX mode, the exit status is that  of  the
last foregrounded

     +o    getopts.  In POSIX mode, options must start with a `-';
in non-POSIX
         mode, options can start with either `-' or `+'.

     +o   Brace expansion (also known as alternation).   In  POSIX
mode, brace
         expansion  is  disabled; in non-POSIX mode, brace expansion is enabled.
         Note that set -o posix (or setting  the  POSIXLY_CORRECT
parameter) automatically
  turns  the braceexpand option off; however,
it can be explicitly
 turned on later.

     +o   set -.  In POSIX mode, this does not clear  the  verbose
or xtrace options;
 in non-POSIX mode, it does.

     +o    set exit status.  In POSIX mode, the exit status of set
is 0 if there
         are no errors; in non-POSIX mode,  the  exit  status  is
that of any command
  substitutions performed in generating the set command.  For example,
 set -- `false`; echo $? prints 0 in POSIX mode, 1
in non-POSIX
         mode.  This construct is used in most shell scripts that
use the old
         getopt(1) command.

     +o   Argument expansion of the alias, export,  readonly,  and
typeset commands.
   In  POSIX  mode,  normal  argument expansion is
done; in nonPOSIX
 mode, field splitting, file globbing, brace expansion, and
         (normal)  tilde  expansion are turned off, while assignment tilde expansion
 is turned on.

     +o   Signal specification.  In POSIX  mode,  signals  can  be
specified as
         digits, only if signal numbers match POSIX values (i.e.,
         INT=2, QUIT=3, ABRT=6, KILL=9, ALRM=14, and TERM=15); in
         mode, signals can always be digits.

     +o   Alias expansion.  In POSIX mode, alias expansion is only
carried out
         when reading command words; in non-POSIX mode, alias expansion is
         carried out on any word following an alias that ended in
a space.
         For example, the following for loop

               alias a='for ' i='j'
               a i in 1 2; do echo i=$i j=$j; done

         uses parameter i in POSIX mode, j in non-POSIX mode.

     +o   Test.  In POSIX mode, the expression `-t'  (preceded  by
some number of
         `!' arguments) is always true as it is a non-zero length
string; in
         non-POSIX mode, it tests if file descriptor 1 is  a  tty
(i.e., the fd
         argument  to the -t test may be left out and defaults to

   Command execution    [Toc]    [Back]
     After evaluation of  command-line  arguments,  redirections,
and parameter
     assignments,  the  type  of command is determined: a special
built-in, a
     function, a regular built-in, or the name of a file to  execute found using
  the  PATH  parameter.  The checks are made in the above
order.  Special
     built-in commands differ from other  commands  in  that  the
PATH parameter
     is  not  used to find them, and an error during their execution can cause a
     non-interactive shell to exit and parameter assignments that
are specified
  before  the  command  are  kept after the command completes.  Just to
     confuse things, if the posix option is turned off  (see  the
set command
     below),  some  special  commands are very special in that no
field splitting,
 file globbing, brace expansion, nor tilde expansion is
performed on
     arguments that look like assignments.  Regular built-in commands are different
 only in that the PATH parameter is not used  to  find

     The original ksh and POSIX differ somewhat in which commands
are considered
 special or regular:

     POSIX special commands

     ., :, break, continue, eval, exec, exit,  export,  readonly,
return, set,
     shift, trap, unset

     Additional ksh special commands

     builtin, times, typeset

     Very special commands (non-POSIX)

     alias, readonly, set, typeset

     POSIX regular commands

     alias,  bg, cd, command, false, fc, fg, getopts, jobs, kill,
read, true,
     umask, unalias, wait

     Additional ksh regular commands

     [, echo, let, print, pwd, test, ulimit, whence

     In the future, the additional ksh special and  regular  commands may be
     treated  differently from the POSIX special and regular commands.

     Once the type of the command has been determined,  any  command-line parameter
 assignments are performed and exported for the duration
of the command.

     The following describes the  special  and  regular  built-in

     . file [arg1 ...]
             Execute the commands in file in the current environment.  The
             file is searched for in the directories of PATH.  If
             are  given, the positional parameters may be used to
access them
             while file is being executed.  If no  arguments  are
given, the positional
 parameters are those of the environment the
command is
             used in.

     : [...]
             The null command.  Exit status is set to zero.

     alias [-d | +-t [-r]] [+-px] [+-] [name[=value] ...]
              Without arguments, alias lists  all  aliases.   For
any name without
 a value, the existing alias is listed.  Any name
with a value
             defines an alias (see Aliases above).

             When listing aliases, one of two  formats  is  used.
             aliases  are  listed  as  name=value, where value is
quoted.  If options
 were preceded with `+', or a lone `+' is given
on the command
  line,  only  name is printed.  In addition, if
the -p option
             is used, each alias  is  prefixed  with  the  string
``alias ''.

             The  -x option sets (+x clears) the export attribute
of an alias,
             or, if no names are given, lists  the  aliases  with
the export attribute
 (exporting an alias has no effect).

             The  -t option indicates that tracked aliases are to
be listed/set
             (values specified on the command  line  are  ignored
for tracked
             aliases).   The -r option indicates that all tracked
aliases are
             to be reset.

             The -d option causes directory  aliases,  which  are
used in tilde
             expansion,  to be l

 Similar pages
Name OS Title
ulimit OpenBSD public domain Korn shell
ksh OpenBSD public domain Korn shell
rksh OpenBSD public domain Korn shell
ksh Linux Public domain Korn shell
bash Linux GNU Bourne-Again SHell
sh Tru64 The Bourne shell, an interactive command interpreter and command programming language
Rsh Tru64 The Bourne shell, an interactive command interpreter and command programming language
ssh-pubkeymgr Tru64 Configures Secure Shell public key user authentication
ssh-hostbased-setup Tru64 Sets up Secure Shell host-based authentication by verifying and if necessary, copying a public host ...
sh Tru64 Shell, the standard command language interpreter (POSIX Shell)
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service