unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

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

sh(1)                            User Commands                           sh(1)



NAME
       sh, jsh - standard and job control shell and command interpreter

SYNOPSIS
       /usr/bin/sh [-acefhiknprstuvx] [argument...]

       /usr/xpg4/bin/sh [ +- abCefhikmnoprstuvx] [ +- o option...] [-c string]
       [arg...]

       /usr/bin/jsh [-acefhiknprstuvx] [argument...]

DESCRIPTION
       The /usr/bin/sh utility is a command programming language that executes
       commands read from a terminal or a file.

       The /usr/xpg4/bin/sh utility is a standards compliant shell. This util-
       ity provides all the functionality of ksh(1), except in cases discussed
       in ksh(1) where differences in behavior exist.

       The  jsh  utility is an interface to the shell that provides all of the
       functionality of sh and enables job control (see  Job  Control  section
       below).

       Arguments to the shell are listed in the Invocation section below.

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

USAGE
   Commands
       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 (see
       exec(2)). The value of a simple-command is its exit status if it termi-
       nates  normally, or (octal) 200+status if it terminates abnormally. See
       signal.h(3HEAD) for a list of status values.

       A pipeline is a sequence of one or more commands separated  by  |.  The
       standard  output of each command 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 in
       the pipeline.

       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 sym-
       bols &&&& and || also have  equal  precedence.  A  semicolon  (;)  causes
       sequential  execution  of  the  preceding  pipeline, that is, the shell
       waits for the pipeline to finish before executing any commands  follow-
       ing  the  semicolon.  An ampersand (&&) causes asynchronous execution of
       the preceding pipeline, that is, the shell does not wait for that pipe-
       line  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 newlines may appear in a list, instead
       of semicolons, to delimit commands.

       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

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



       case word in [ pattern [ | pattern ] ) list ;; ] ...  esac

           A case command executes the list associated with the first  pattern
           that  matches  word.  The  form of the patterns is the same as that
           used for file-name generation (see File Name  Generation  section),
           except  that a slash, a leading dot, or a dot immediately following
           a slash need not be matched explicitly.



       if list ; then list ; [ elif list ; then list ; ] ... [ else list  ;  ]
       fi

       The  list  following if is executed and, if it returns a zero exit sta-
       tus, the list following the first then is executed. Otherwise, the list
       following  elif is executed and, if its value is zero, the list follow-
       ing 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 sub-shell.



       { list;}                        list is executed in the  current  (that
                                       is,  parent)  shell. The { must be fol-
                                       lowed by a space.



       name () { list;}                Define a function which  is  referenced
                                       by  name.  The  body of the function is
                                       the list of commands between {  and  }.
                                       The { must be followed by a space. Exe-
                                       cution of functions is described  below
                                       (see  Execution  section).  The { and }
                                       are unnecessary  if  the  body  of  the
                                       function is a command as defined above,
                                       under Commands.



       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 Lines
       A word beginning with # causes that word and all the following  charac-
       ters up to a newline to be 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 newlines 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. Back-
       slashes  may  be used to escape a grave accent (`) or another backslash
       (\) and are removed before the command string is read.  Escaping  grave
       accents allows nested command substitution. If the command substitution
       lies within a pair of double quotes (" ...` ...` ...  "),  a  backslash
       used  to escape a double quote (\") will be removed; otherwise, it will
       be left intact.

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

   Parameter Substitution
       The character $ is used to introduce  substitutable  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 substi-
                               tuted. The braces are required only when param-
                               eter  is followed by a letter, digit, or under-
                               score that is not to be interpreted as part  of
                               its name. If parameter is * or @, all the posi-
                               tional parameters, starting with $1,  are  sub-
                               stituted (separated by spaces). Parameter $0 is
                               set  from  argument  zero  when  the  shell  is
                               invoked.



       ${parameter:-word}      If parameter is set and is non-null, substitute
                               its value; otherwise substitute word.



       ${parameter:=word}      If parameter is not set or is null  set  it  to
                               word;  the  value  of  the parameter is substi-
                               tuted.  Positional  parameters   may   not   be
                               assigned in this way.



       ${parameter:?word}      If parameter is set and is non-null, substitute
                               its value; otherwise, print word and exit  from
                               the  shell.  If  word  is  omitted, the message
                               "parameter null or not set" is printed.



       ${parameter:+word}      If parameter is set and is non-null, 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`}

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



       ?               The  decimal  value  returned by the last synchronously
                       executed command.



       $               The process number of this shell.



       !               The process  number  of  the  last  background  command
                       invoked.



       The  following parameters are used by the shell. The parameters in this
       section are also referred to as environment variables.

       HOME            The default argument (home directory) for the  cd  com-
                       mand,  set  to  the  user's login directory by login(1)
                       from the password file (see passwd(4)).



       PATH            The search path for  commands  (see  Execution  section
                       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 prompt.



       MAILPATH        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
                       newline (see Blank Interpretation section).



       SHACCT          If this parameter is set to the name of a file writable
                       by the user, the shell will write an accounting  record
                       in the file for each shell procedure executed.



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



       See environ(5) for descriptions of the following environment  variables
       that affect the execution of sh: LC_CTYPE and LC_MESSAGES.

       The  shell  gives default values to PATH, PS1, PS2, MAILCHECK, and IFS.
       Default values for 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 Redirection
       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 as
       arguments to the invoked command. Note: Parameter and command substitu-
       tion 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;>&gt;word          Open  file  word  for  reading  and writing as standard
                       input.



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


                           1.  leading  tabs are stripped from word before the
                               shell input is read (but  after  parameter  and
                               command substitution is done on word);


                           2.  leading  tabs are stripped from the shell input
                               as it is read and before each line is  compared
                               with word; and


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


                           1.  parameter and command substitution occurs;


                           2.  (escaped) \newlines are removed; and


                           3.  \  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  stan-
                       dard 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>&gt;&&amp;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>&gt;xxx 2>&1

       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.

       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.

   File Name 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 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 char-
       acter / 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.



       Notice  that  all quoted characters (see below) must be matched explic-
       itly in a filename.

   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 (that is, made to stand for itself) by pre-
       ceding it with a backslash (\) or inserting it between a pair of  quote
       marks  ('' or ""). During processing, the shell may quote certain char-
       acters 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,  "'"),  but  a
       single quote can not be quoted inside a pair of single quotes.

       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 \,
       `, , (comma), and $. The pair \newline is removed before parameter  and
       command  substitution. If a backslash precedes characters other than \,
       `, , (comma), $, 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 newline is typed and further  input
       is  needed  to  complete  a command, the secondary prompt (that is, the
       value of PS2) is issued.

   Environment
       The environment (see environ(5)) 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=450  command

       and

       (export TERM; TERM=450;   command

       are  equivalent as far as the execution of command is concerned if com-
       mand is not a Special Command. If command is a Special Command, then

       TERM=450   command

       will modify the TERM variable in the current shell.

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

       echo a=b  c

       a=b  c

       set  -k

       echo a=b  c

       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, with the exception of signal 11 (but
       see also the trap command below).

   Execution
       Each  time  a  command is executed, the command substitution, parameter
       substitution, blank interpretation, input/output redirection, and file-
       name  generation  listed  above  are  carried  out. If the command name
       matches the name of a defined function, the function is executed in the
       shell process (note how this differs from the execution of shell script
       files, which require a sub-shell for invocation). If the  command  name
       does  not  match the name of a defined function, but matches one of the
       Special Commands listed below, it is executed in the shell process.

       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 con-
       taining the command. Alternative directory names  are  separated  by  a
       colon (:). The default path is /usr/bin. The current directory is spec-
       ified by a null path name, which can appear immediately after the equal
       sign, between two colon delimiters anywhere in the path list, or at the
       end of the path list. If the command name contains a / the search  path
       is  not  used. Otherwise, each directory in the path is searched for an
       executable file. If the file has execute permission but is not an 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 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.  When Job Control is
       enabled, additional Special Commands are added to the shell's  environ-
       ment (see Job Control section below).

       :

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



       . filename

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



       bg [%jobid ...]

           When  Job Control is enabled, the bg command is added to the user's
           environment to manipulate jobs. Resumes the execution of a  stopped
           job  in  the  background.  If  %jobid is omitted the current job is
           assumed. (See Job Control section below for more detail.)



       break [ n ]

           Exit from the enclosing for or while loop, if any. If n  is  speci-
           fied, break n levels.



       cd [ argument ]

           Change  the current directory to argument. The shell parameter HOME
           is the default argument. The shell  parameter  CDPATH  defines  the
           search  path  for  the  directory  containing argument. Alternative
           directory names are separated by a colon (:). The default  path  is
           <&lt;null>&gt; (specifying the current directory). Note: The current direc-
           tory 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.



       chdir [ dir ]

           chdir changes the shell's working directory to directory dir. If no
           argument is given, change to the home directory of the user. If dir
           is a relative pathname not found in the  current  directory,  check
           for  it  in those directories listed in the CDPATH variable. If dir
           is the name of a shell variable whose value starts with a /, change
           to the directory named by that value.



       continue [ n ]

           Resume  the next iteration of the enclosing for or while loop. If n
           is specified, resume at the n-th enclosing loop.



       echo [ arguments ... ]

           The words in arguments are written to the shell's standard  output,
           separated  by  space  characters.  See echo(1) for fuller usage and
           description.



       eval [ argument ... ]

           The arguments are read as input to the shell and the resulting com-
           mand(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  arguments  are  given, cause the shell
           input/output to be modified.



       exit [ n ]

           Causes the calling shell or shell script to exit with the exit sta-
           tus  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, vari-
           able names that have been marked  for  export  during  the  current
           shell's  execution are listed. (Variable names exported from a par-
           ent shell are listed only if they have been exported  again  during
           the current shell's execution.) Function names are not exported.



       fg [%jobid ...]

           When  Job Control is enabled, the fg command is added to the user's
           environment to manipulate jobs. This command resumes the  execution
           of  a  stopped  job  in  the foreground and also moves an executing
           background job into the foreground. If %jobid is omitted, the  cur-
           rent  job  is  assumed.  (See  Job  Control  section below for more
           detail.)



       getopts

           Use in shell scripts  to  support  command  syntax  standards  (see
           intro(1)). This command parses positional parameters and checks for
           legal options. See getoptcvt(1) for usage and description.



       hash [ -r ] [ name ... ]

           For each name, the location in the search path of the command spec-
           ified  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 pre-
           sented. 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 location 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 incremented when  the  recalculation
           is done.



       jobs [-p|-l] [%jobid ...]
       jobs -x command [arguments]

           Reports  all  jobs that are stopped or executing in the background.
           If %jobid is omitted, all jobs that are stopped or running  in  the
           background  will  be  reported.  (See Job Control section below for
           more detail.)




       kill [ -sig ] %job ...
       kill -l

           Sends either the TERM (terminate) signal or the specified signal to
           the specified jobs or processes. Signals are either given by number
           or by names (as given in signal.h(3HEAD)  stripped  of  the  prefix
           "SIG"  with the exception that SIGCHD is named CHLD). If the signal
           being sent is TERM (terminate) or HUP (hangup),  then  the  job  or
           process will be sent a CONT (continue) signal if it is stopped. The
           argument job can be the process id of a process that is not a  mem-
           ber  of one of the active jobs. See Job Control section below for a
           description of the format of job. In the second form, kill -l,  the
           signal numbers and names are listed. (See kill(1)).




       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  space  or  tab), to delimit word
           boundaries, the first word is assigned to the first name, the  sec-
           ond  word  to  the  second  name, and so forth, 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 interpretation is done on the character
           that follows the backslash. The return code is 0, unless an EOF  is
           encountered.



       readonly [ name ... ]

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



       return [ n ]

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



       set [ -aefhkntuvx [ argument ... ] ]


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




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



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



           Using  +  rather  than - causes these flags to be turned off. These
           flags can also be used upon invocation of the  shell.  The  current
           set  of flags may be found in $-. The remaining arguments are posi-
           tional parameters and are assigned, in order, to $1, $2, ... If  no
           arguments are given, the values of all names are printed.


       shift [ n ]

           The  positional  parameters from $n+1 ... are renamed $1 ... . If n
           is not given, it is assumed to be 1.



       stop pid ...

           Halt execution of the process number pid. (see ps(1)).



       suspend

           Stops the execution of the current shell (but  not  if  it  is  the
           login shell).



       test

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



       times

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



       trap [ argument n [ n2 ... ]]

           The  command  argument  is  to  be read and executed when the shell
           receives numeric or symbolic  signal(s)  (n).  (Note:  argument  is
           scanned once when the trap is set and once when the trap is taken.)
           Trap commands are executed in order of signal number or correspond-
           ing  symbolic names. 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 argument is
           absent, all trap(s) n are reset to their original values. If  argu-
           ment is the null string, this signal is ignored by the shell and by
           the commands it invokes. If n is 0, the command  argument  is  exe-
           cuted  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 [ [-HS] [-a | -cdfnstv] ]
       ulimit [ [-HS] [-c | -d | -f | -n | -s | -t | -v] ] limit

           ulimit  prints  or  sets hard or soft resource limits. These limits
           are described in getrlimit(2).

           If limit is not present, ulimit prints the  specified  limits.  Any
           number  of  limits may be printed at one time. The -a option prints
           all limits.

           If limit is present, ulimit sets the specified limit to limit.  The
           string  unlimited  requests  the largest valid limit. Limits may be
           set for only one resource at a time. Any user may set a soft  limit
           to any value below the hard limit. Any user may lower a hard limit.
           Only a super-user may raise a hard limit. (See su(1M).)

           The -H option specifies a hard limit. The  -S  option  specifies  a
           soft  limit.  If  neither option is specified, ulimit will set both
           limits and print the soft limit.

           The following options specify the resource whose limits are  to  be
           printed  or  set. If no option is specified, the file size limit is
           printed or set.


           -c       maximum core file size (in 512-byte blocks)





           -d       maximum size of data segment or heap (in kbytes)



           -f       maximum file size (in 512-byte blocks)



           -n       maximum file descriptor plus 1



           -s       maximum size of stack segment (in kbytes)



           -t       maximum CPU time (in seconds)



           -v       maximum size of virtual memory (in kbytes)


           Run the sysdef(1M) command to obtain the  maximum  possible  limits
           for  your  system.  The values reported are in hexadecimal, but can
           be translated into decimal numbers using the  bc(1)  utility.   See
           swap(1M).)

           As an example of ulimit, to limit the size of a core file dump to 0
           Megabytes, type the following:

           ulimit -c 0



       umask [ nnn ]

           The user file-creation mask is set to nnn (see umask(1)). If nnn is
           omitted, the current value of the mask is printed.



       unset [ name ... ]

           For each name, remove the corresponding variable or function value.
           The variables PATH, PS1, PS2, MAILCHECK, and IFS cannot be unset.



       wait [ n ]

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



   Invocation
       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
       /usr/bin/sh. The flags below are interpreted by the shell on invocation
       only. Note: 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.



       -i              If the -i flag 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.



       -p              If  the  -p flag is present, the shell will not set the
                       effective user and group IDs to the real user and group
                       IDs.



       -r              If  the  -r  flag  is present the shell is a restricted
                       shell (see rsh(1M)).



       -s              If the -s flag 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.



       The remaining flags and arguments are described under the  set  command
       above.

   Job Control (jsh)
       When the shell is invoked as jsh, Job Control is enabled in addition to
       all of the functionality described previously for  sh.  Typically,  Job
       Control  is  enabled  for  the  interactive shell only. Non-interactive
       shells typically do not benefit from the  added  functionality  of  Job
       Control.

       With  Job Control enabled, every command or pipeline the user enters at
       the terminal is called a job. All jobs exist in one  of  the  following
       states:  foreground, background, or stopped. These terms are defined as
       follows:

       1.  A job in the foreground has read and write access to  the  control-
           ling terminal.


       2.  A  job  in the background is denied read access and has conditional
           write access to the controlling terminal (see stty(1)).


       3.  A stopped job is a job that has been placed in a  suspended  state,
           usually as a result of a SIGTSTP signal (see signal.h(3HEAD)).


       Every  job that the shell starts is assigned a positive integer, called
       a job number which is tracked by the shell and will be used as an iden-
       tifier  to indicate a specific job. Additionally, the shell keeps track
       of the current and previous jobs. The current job is  the  most  recent
       job  to be started or restarted. The previous job is the first non-cur-
       rent job.

       The acceptable syntax for a Job Identifier is of the form:

       %jobid

       where jobid may be specified in any of the following formats:

       % or +          For the current job.



       -               For the previous job.



       ?&lt;string&gt;       Specify the job for which  the  command  line  uniquely
                       contains string.



       n               For job number n.



       pref            Where  pref is a unique prefix of the command name. For
                       example, if the command ls -l name were running in  the
                       background, it could be referred to as %ls. pref cannot
                       contain blanks unless it is quoted.



       When Job Control is enabled, the following commands are  added  to  the
       user's environment to manipulate jobs:

       bg [%jobid ...]

           Resumes the execution of a stopped job in the background. If %jobid
           is omitted the current job is assumed.



       fg [%jobid ...]

           Resumes the execution of a stopped  job  in  the  foreground,  also
           moves an executing background job into the foreground. If %jobid is
           omitted the current job is assumed.



       jobs [-p|-l] [%jobid ...]
       jobs -x command [arguments]

           Reports all jobs that are stopped or executing in  the  background.
           If  %jobid  is omitted, all jobs that are stopped or running in the
           background will be  reported.   The  following  options  will  mod-
           ify/enhance the output of jobs:

           -l       Report  the  process group ID and working directory of the
                    jobs.





           -p       Report only the process group ID of the jobs.



           -x       Replace any jobid found in command or arguments  with  the
                    corresponding  process  group ID, and then execute command
                    passing it arguments.




       kill [ -signal ] %jobid

           Builtin version of kill to provide the functionality  of  the  kill
           command for processes identified with a jobid.



       stop %jobid ...

           Stops the execution of a background job(s).



       suspend

           Stops  the  execution  of  the  current shell (but not if it is the
           login shell).



       wait [%jobid ...]

           wait builtin accepts a job identifier. If %jobid  is  omitted  wait
           behaves as described above under Special Commands.



   Large File Behavior
       See largefile(5) for the description of the behavior of sh and jsh when
       encountering files greater than or equal to 2 Gbyte ( 2**31 bytes).

EXIT STATUS
       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-interac-
       tively 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).

   jsh Only
       If the shell is invoked as jsh and an attempt is made to exit the shell
       while there are stopped jobs, the shell issues one warning:

       There are stopped jobs.

       This  is  the  only message. If another exit attempt is made, and there
       are still stopped jobs they will be sent a SIGHUP signal from the  ker-
       nel and the shell is exited.

FILES
       $HOME/.profile

       /dev/null

       /etc/profile

       /tmp/sh*

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

   /usr/bin/sh, /usr/bin/jsh
       tab()     allbox;     cw(2.750000i)|    cw(2.750000i)    lw(2.750000i)|
       lw(2.750000i).   ATTRIBUTE  TYPEATTRIBUTE   VALUE   AvailabilitySUNWcsu
       CSIEnabled


   /usr/xpg4/bin/sh
       tab()     allbox;     cw(2.750000i)|    cw(2.750000i)    lw(2.750000i)|
       lw(2.750000i).   ATTRIBUTE  TYPEATTRIBUTE  VALUE   AvailabilitySUNWxcu4
       CSIEnabled


SEE ALSO
       intro(1), bc(1), echo(1), getoptcvt(1), kill(1), ksh(1), login(1), new-
       grp(1), pfsh(1), pfexec(1), ps(1), pwd(1),  set(1),  shell_builtins(1),
       stty(1),  test(1),  umask(1),  wait(1), rsh(1M), su(1M), swap(1M), sys-
       def(1M), dup(2), exec(2), fork(2),  getrlimit(2),  pipe(2),  ulimit(2),
       setlocale(3C),  signal.h(3HEAD),  passwd(4), profile(4), attributes(5),
       environ(5), largefile(5), XPG4(5)

WARNINGS
       The use of setuid shell scripts is strongly discouraged.

NOTES
       Words used for filenames in input/output  redirection  are  not  inter-
       preted  for  filename  generation  (see  File  Name  Generation section
       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  the input or the output of a while or until loop is redirected, the
       commands in the loop are run in  a  sub-shell,  and  variables  set  or
       changed there have no effect on the parent process:

          lastline=
          while read line
          do

                  lastline=$line
          done < /etc/passwd
          echo "lastline=$lastline"       # lastline is empty!

       In these cases, the input or output can be redirected by using exec, as
       in the following example:

          # Save standard input (file descriptor 0) as file
          # descriptor 3, and redirect standard input from the file
          /etc/passwd:

          exec 3<&0               # save standard input as fd 3
          exec </etc/passwd       # redirect input from file

          lastline=
          while read line
          do
                  lastline=$line
          done

          exec 0<&3               # restore standard input
          exec 3<&-               # close file descriptor 3
          echo "$lastline"        # lastline

       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 doesn't help, the system process table is  probably  full  or  you
       have too many active foreground processes. There is a limit to the num-
       ber of process ids associated with your login, and to  the  number  the
       system can keep track of.

       Only the last process in a pipeline can be waited for.

       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.

       The Bourne shell has a limitation on the effective UID for  a  process.
       If  this  UID  is  less  than 100 (and not equal to the real UID of the
       process), then the UID is reset to the real UID of the process.

       Because the shell implements both foreground and background jobs in the
       same  process  group, they all receive the same signals, which can lead
       to unexpected behavior. It is, therefore, recommended  that  other  job
       control shells be used, especially in an interactive environment.

       When  the shell executes a shell script that attempts to execute a non-
       existent command interpreter, the shell returns an erroneous diagnostic
       message that the shell script file does not exist.




SunOS 5.10                        19 Sep 2003                            sh(1)