sh — Invoke a shell

sh contains the following subsections:

• Options and invocation
• Command syntax
• Command execution
• Quoting
• Directory substitution
• Parameter substitution
• Arithmetic substitution
• Command substitution
• File descriptors and redirection
• File name generation
• Variables
• Shell execution environments
• Built-in commands

If you invoke the shell with a name that begins with the – character, it is a login shell. (You can also get a login shell if you invoke the shell with the –L option.) A login shell begins by running the file /etc/profile. It then runs $HOME/.profile using the . command (see dot). If $HOME is not set, the shell searches the working directory for:

.profile

and runs this file with the . command if it exists. You do not get an error message if any of these files cannot be found.

The shell accepts the following options on the command line:

–c cmdstring

Runs cmdstring as if it were an input line to the shell and then exits. This is used by programs (for example, editors) that call the shell for a single command. sh assigns arguments after cmdstring to the positional parameters. If you specify cmd_name, special parameter 0 is set to this string for use when running the commands in cmdstring.

–i

Invokes an interactive shell, as opposed to running a script. With –i, the shell catches and ignores interrupts. Without –i, an interrupt ends the shell. For shells that read from the terminal, –i is the default.

–K

Specifies KornShell-compatible behavior where the POSIX.2 behavior is different from the behavior specified by the KornShell. Without -K, the shell defaults to POSIX.2 behavior.

–L

Makes the shell a login shell, as described earlier.

–r

Invokes a restricted shell. (As noted earlier, you can also invoke a restricted shell by using the name rsh). In a restricted shell, you cannot do the following: use the cd command; change the values of the variables ENV, PATH, or SHELL; use > or >> to redirect output; or specify command names containing /. These restrictions do not apply during execution of your profile files.

–s

Reads commands from standard input and assigns all arguments to the positional parameters. Normally, if there is at least one argument to the shell, the first such argument is the name of a file to run.

The shell implements a sophisticated programming language that gives you complete control over the execution and combination of individual commands. When the shell scans its input, it always treats the following characters specially:

*   ;   &   (   )   <   >   |   '   \   "
space   tab   newline

If you want to use any of these characters inside an actual argument, you must quote the argument (so that the shell doesn't use the special meanings of the characters). See Quoting for more information.

A command can be any of the following:

command:

simple command
reserved-word command
(command)
command | command
command && command
command || command
command & command
command &
command |&
command ; command
command ;
command<newline>

The following is the order of precedence of the preceding operators. The highest priority operators are listed first, and operators on the same line have equal priority.

()
|
&&     ||
&      |&       ;      <newline>

The meaning of these operations is as follows:

(command)

Runs command in a subshell. The current shell invokes a second shell, and this second shell actually runs command. In this way, command runs in a completely separate execution environment; it can change working directories, change variables, open files, and so on without affecting the first shell. The subshell's environment begins as a copy of the current environment, so the value of the ENV environment variable is not run when a subshell starts.

|

Creates a pipe between the two commands that the | operator connects. The standard output of the first command becomes the standard input of the second command. A series of commands connected by pipes is called a pipeline. The exit status is that of the last command in the pipeline.

&&

Is the logical AND operator. The shell runs the second command if and only if the first command returns a true (zero) exit status.

||

This is the logical OR operator. The shell runs the second command if and only if the first command returns a false (nonzero) exit status.

&

Runs the command that precedes it asynchronously. The shell just starts the command running and then immediately goes on take new input, before the command finishes execution. On systems where asynchronous execution is not possible, this operation is effectively equivalent to ;.

|&

Runs the command that precedes it as a co-process. The command runs asynchronously, as with the & operator, but the command's standard input and standard output are connected to the shell by pipes. The shell sends input to command 's standard input with the print –p command, and reads from command's standard output with the read –p command. The command should not buffer its output. Because of this and other limitations, co-processes should be designed to be used as co-processes. On systems where asynchronous execution is not possible, co-processes are not supported.

;

Is the sequential execution operator. The second command is run only after the first command has completed.

newline

The unescaped newline is equivalent to the ; operator.

The shell contains a rich set of reserved-word commands, which provide flow of control and let you create compound commands. In the following list, a command can also be a sequence of commands separated by newlines. Square brackets ([ ]) indicate optional portions of commands, and are never part of the command syntax.

! command

The exclamation point is the logical NOT operator. When command returns false (nonzero), ! returns true (zero). When command returns true (zero), ! returns false (nonzero).

{ command;}

Enclosing a command in braces is similar to the (command) construct, except that the shell runs the command in the same environment rather than under a subshell. { and } are simply reserved words to the shell. To make it possible for the shell to recognize these symbols, you must put a blank or newline after the {, and a semicolon or newline before the }.

case word in | [(][pattern[|pattern] ... )command ;;] ... | [(][pattern[| pattern] ... )command ;; ] ... | esac

The case statement is similar to the switch statement of the C programming language or the case statement of Pascal. If the given word matches any one of the patterns separated by or bar (|) characters, sh runs the corresponding command. The patterns should follow the rules given in File Name Generation, except that the period (.) and slash (/) are not treated specially. Patterns are matched in the order they are given, so more inclusive patterns should be mentioned later. You must use the double semicolon (;;) to delimit command and introduce the next pattern.

for variable [in word ...] | do command | done

The for statement sets variable to each word argument in turn, and runs the set of commands once for each setting of variable. If you omit the in word part, sh sets variable to each positional parameter. You can divert the flow of control within the loop with the break or continue statements.

function variable { | command | } | variable() { | command | }

Any one of these forms defines a function named variable, the body of which consists of the sequence of commands. You invoke a function just like any other command; when you actually call the function, sh saves the current positional parameters. The function's command-line arguments then replaces these parameters until the function finishes. sh also saves the current ERR and EXIT traps and any flags manipulated with the set command; these are restored when the function finishes. The function ends either by falling off the end of the code of the function body, or by reaching a return statement. If the function uses typeset to declare any variables in the function body, the variables are local to the function.

if command | then command | [elif command | then command] ... | [else command] | fi

In the if statement, if the first (leftmost) command succeeds (returns a zero exit status), sh runs the command following then. Otherwise, sh runs the command (if any) following the elif (which is short for else if); if that succeeds, sh runs the command following the next then. If neither case succeeds, sh runs the command following the else (if any).

select variable [in word ...] | do commands | done

The select statement can handle menulike interactions with the user. Its syntax is like the for statement. Each word is printed on the standard error file, one per line, with an accompanying number. If you omit the “in word ...” part, sh uses the positional parameters. sh then displays the value of the variable PS3 to prompt the user to enter a numerical reply. If the reply is an empty line, sh displays the menu again; otherwise, sh assigns the input line to the variable REPLY, sets variable to the word selected, and then runs the commands. sh does this over and over until the loop is ended by an interrupt, an end-of-file, or an explicit break statement in the commands.

until command1 | do command2 | done

The until statement runs command1 and tests its exit status for success (zero) or failure (nonzero). If command1 succeeds, the loop ends; otherwise, sh runs command2 and then goes back to run and test command1 again. break and continue commands in the commands can affect the operation of the loop.

while command1 | do command2 | done

The while statement works similarly to the until statement. However, the loop ends whenever command1 is unsuccessful (nonzero exit status).

If the command name is not a function or a built-in command, the shell looks for a program file or script file that contains an executable version of that command. The OpenExtensions shell uses the following procedure to locate the program file:

• If the command name typed to the shell has slash (/) characters in its name, the command is taken to be a full path name (absolute or relative). The shell tries to execute the contents of that file.
• Otherwise, the shell performs a path search. To do this, the shell obtains the value of the PATH environment variable. The value should be a list of directory names. sh searches under each directory for a file, the name of which matches the command name. sh runs the first matching file found.

As an alternative, you can put arguments in various types of quotes. Different quotation mark characters have different strengths. The single quotation mark characters are the strongest. When you enclose a command-line argument in single quotation mark characters, the shell disregards the special meanings of everything inside the single quotation marks. For example:

 echo '*'

displays just the * character.

Double quotation mark characters are weaker. Inside double quotation marks, the shell performs command substitutions of the form:

$(command)

or:

command

(See Command Substitution.) The shell does not perform such substitutions when they appear inside single quotation marks. In addition, the shell performs parameter substitutions of the form:

$parameter

when they are inside double quotation marks but not when they're inside single quotation marks (see Parameter Substitution). You can use the backslash to escape another character when they appear inside double quotation marks, but inside single quotation marks the shell ignores this special meaning.

Quoting can override the special meanings of reserved words and aliases. For example, in:

"time" program

the quotes around time tell the shell not to interpret time as a shell reserved word. Instead, sh does a normal command search for a command named time.

You must always quote the following characters if you want sh to interpret them literally:

|   &   ;   <   >   (   )   $    '   "   ˋ   \
<space>  <tab>  <newline>

The following characters need to be quoted in certain contexts if they are to be interpreted literally:

*   ?   [   #   %   =   ~

For example, if you specify a file name as:

 ~jsmith/file
sh would look up jsmith's home
directory and put that directory name in place
of the  ~jsmith
construct.

If you specify a ~ without an accompanying name, sh replaces the ~ with the current value of your HOME variable (see Environment Variables). For example:

echo  ~
displays the name of your home directory. Similarly, sh replaces
the construct  ~+ with the value of the PWD variable (the name of the
your working directory), and replaces the tilde hyphen ( ~–) with the
value of OLDPWD (the name of your previous working directory). In variable
assignments, tilde expansion is also performed after colons (:).

A special parameter is represented with one of the following characters:

*    @    #    ?    !    -    $     0

The values to which special parameters expand are listed in the following paragraphs.

The simplest way to use a parameter in a command line is to enter a dollar sign ($) followed by the name of the parameter. For example, if you enter the command:

echo $x

sh replaces $x with the value of the parameter x and then displays the results (because echo displays its arguments). Other ways to expand parameters are shown in the following paragraphs.

The following parameters are built in to the shell:

$1, $2, ... $9

Expands to the d positional parameter (where d is the single digit following the $). If there is no such parameter, $d expands to a null string.

$0

Expands to the name of the shell, the shell script, or a value assigned when you invoked the shell.

$#

Expands to the number of positional parameters.

$@

Expands to the complete list of positional parameters. If $@ is quoted, the result is separate arguments, each quoted. This means that:

"$@"

is equivalent to:

"$1" "$2" ...

$*

Expands to the complete list of positional parameters. If $* is quoted, the result is concatenated into a single argument, with parameters separated by the first character of the value of IFS (Variables). For example, if the first character of IFS is a blank, then:

"$*"

is equivalent to:

"$1 $2 ..."

$–

Expands to all options that are in effect from previous calls to the set command and from options on the sh command line.

$?

Expands to the exit status of the last command run.

$$

Expands to the current process number of the original parent shell.

$!

Expands to the process number of the last asynchronous command.

We have already mentioned that you can expand a parameter by putting a $ in front of the parameter name. More sophisticated ways to expand parameters are:

${parameter}

Expands any parameter.

${number}

Expands to the positional parameter with the given number. (Remember that if you just enter $d to refer to the dth positional parameter, d can only be a single digit; with brace brackets, number can be greater than 9.) Since braces mark the beginning and end of the name, you can have a letter or digit immediately following the expression.

${variable[arithmetic expression]}

Expands to the value of an element in an array named variable. The arithmetic expression gives the subscript of the array. (See Arithmetic Substitution.)

${variable[*]}

Expands to all the elements in the array variable, separated by the first character of the value of $IFS

${variable[@]}

When unquoted, is the same as ${variable[*]}. When quoted as ${variable[@]}, it expands to all the elements in the array variable, with each element quoted individually.

${#parameter}

Expands to the number of characters in the value of the given parameter.

${#*}, ${#@}

Expands to the number of positional parameters.

${#variable[*]}

Expands to the number of elements in the array named variable. Elements that do not have assigned values do not count. For example, if you only assign values to elements 0 and 4, the number of elements is 2. Elements 1 through 3 do not count.

${parameter:–word}

Expands to the value of parameter if it is defined and has a nonempty value; otherwise, it expands word. This means that you can use word as a default value if the parameter isn't defined.

${parameter–word}

Is similar to the preceding construct, except that the parameter is expanded if defined, even if the value is empty.

${variable:=word}

Expands word with parameter expansion and assigns the result to variable, provided that variable is not defined or has an empty value. The result is the expansion of variable, whether or not word was expanded.

${variable=word}

Is similar to the preceding construct, except that the variable must be undefined (it cannot just be null) for word to be expanded.

${parameter:?word}

Expands to the value of parameter provided that it is defined and non-empty. If parameter isn't defined or is null, sh expands and displays word as a message. If word is empty, sh displays a default message. After a noninteractive shell has displayed a message, it ends.

${parameter?word}

Is similar to the preceding construct, except that sh displays word only if parameter is undefined.

${parameter:+word}

Expands to word, provided that parameter is defined and nonempty.

${parameter+word}

Expands to word, provided that parameter is defined.

${parameter#pattern}

Attempts to match pattern against the value of the specified parameter. The pattern is the same as a case pattern. sh searches for the shortest prefix of the value of parameter that matches pattern. If sh finds no match, the previous construct expands to the value of parameter; otherwise, the portion of the value that matched pattern is deleted from the expansion.

${parameter##pattern}

Is similar to the preceding construct, except that sh deletes the longest part that matches pattern if it finds such a match.

${parameter%pattern}

Searches for the shortest suffix of the value of parameter matching pattern and deletes the matching string from the expansion.

${parameter%%pattern}

Is similar to the preceding construct, except that sh deletes the longest part that matches pattern if it finds such a match.

Arithmetic substitution is available with the syntax:

$((arithmetic expression))

or:

$[arithmetic expression]

This sequence is replaced with the value of arithmetic expression. Arithmetic expressions consist of expanded variables, numeric constants, and operators. Numeric constants have the form:

[base#]number

where the optional base is a decimal integer between 2 and 36 inclusive, and number is any nonnegative number in the given base. The default base is 10. Undefined variables evaluate to zero.

The operators are listed in decreasing order of precedence in Table 1. Operators sharing a heading have the same precedence. Evaluation within a precedence group is from left to right, except for the assignment operator, which evaluates from right to left.

Arithmetic expressions can be used without the enclosing $(( and )) in assignment to an integer variable (see typeset) as an argument to the following built-in commands:

break	exit	return
continue	let	shift

and when used as arguments in test numeric comparisons (–eq, –ge, –gt, –le, –lt, and -ne) (see test).

The first syntax (called backquoting) surrounds a command with grave accents ˋ, as in:

ls -l ˋcat listˋ

To process this command line, sh first runs the cat command and collects its standard output. The shell then breaks this output into arguments and puts the result into the command line of the ls command. The previous command therefore lists the attributes of all files, the names of which are contained in the file list.

This syntax is easy to type, but is not useful if you want to put one command substitution inside another (nesting command substitutions). A more useful syntax is:

$(command)

as in:

ed $(grep -f -l function $(find . -name '*.c'))

This command uses find to search the current directory and its subdirectories to find all files, the names of which end in .c. It then uses grep –f to search each such file for those that contain the string function. Finally, it calls ed to edit each such file.

There is a historical inconsistency in the backquoting syntax. A backslash (\) within a backquoted command is interpreted differently depending on its context. Backslashes are interpreted literally unless they precede a dollar sign ($), grave accent ( ˋ), or another backslash (\). In these cases, the leading backslash becomes an escape character to force the literal interpretation of the $, ˋ, or \. Consequently, the command:

echo '\$x'

issued at system level produces the output:

\$x

whereas the same command nested in a backquoted syntax:

echo ˋecho '\$x'ˋ

produces the output:

$x

We recommend the $(command) syntax for command substitutions.

Some file descriptors are set up at the time the shell starts up. These are the standard input/output streams:

• Standard input (file descriptor 0)
• Standard output (file descriptor 1)
• Standard error (file descriptor 2)

Commands running under the shell can use these descriptors and streams too. When a command runs under the shell, the streams are normally associated with your terminal. However, you can redirect these file descriptors to associate them with other files (so that I/O on the stream takes place on the associated file instead of your terminal). In fact, the shell lets you redirect the I/O streams associated with file descriptors 0 through 9, using the following command-line constructs.

number<file

Uses file for input on the file descriptor, the number of which is number. If you omit number, as in <file, the default is 0; this redirects the standard input.

number>file

Uses file for output on the file descriptor, the number of which is number. If you omit number, as in >file, the default is 1; this redirects the standard output. The shell creates the file if it doesn't already exist. The redirection fails if the file already exists and noclobber is set (see set).

number>|file

Is similar to number>file but if file already exists, the output written to the file overwrites its current contents.

number< >file

Uses file for input and output with the file descriptor, the number of which is number. This is most useful when the file is another terminal or modem line. If you omit number, as in < >file, the default number is zero; this redirects the standard input. Output written to the file overwrites the current contents of the file (if any). The shell creates the file if it doesn't already exist.

number>>name

Is similar to number > file, except that output is appended to the current contents of the file (if any).

number<<[-]name

Lets you specify input to a command from your terminal (or from the body of a shell script). This notation is known as a here-document. The shell reads from the standard input and feeds that as input to file descriptor number until it finds a line that exactly matches the given name. If you omit number, the default is the standard input. For example, to process the command:

cat <<abc >out

the shell reads input from the terminal until you enter a line that consists of the word abc. This input is passed as the standard input to the cat command, which then copies the text to the file out.

If any character of name is quoted or escaped, sh does not perform substitutions on the input; instead, it performs variable and command substitutions, respecting the usual quoting and escape conventions. If you put - before name, sh deletes all leading tabs in the here-document.

number1<&number2

Makes the input file descriptor number1 a duplicate of file descriptor number2. If you omit number1, the default is the standard input (file descriptor 0). For example, <&4 makes the standard input a duplicate of file descriptor 4. In this case, entering input on 4 has the same effect as entering input on the standard input.

number1>&number2

Makes the output file descriptor number2 a duplicate of file descriptor number2. If you omit number2, the default is the standard output (file descriptor 1). For example, >&2 makes the standard output a duplicate of file descriptor 2 (the standard error). In this case, writing output on the standard output has the same effect as writing output on the standard error.

number<&-

Closes input descriptor number. If you omit number, it closes the standard input.

number>&-

Closes output descriptor number. If you omit number, it closes the standard output.

The characters * ? [ are called glob characters, or wildcard characters. If an unquoted argument contains one or more glob characters, the shell processes the argument for file name generation. The glob characters are part of glob patterns, which represent file and directory names. These patterns are similar to regular expressions, but differ in syntax, since they are intended to match file names and words (not arbitrary strings). The special constructions that may appear in glob patterns are:

?

Matches exactly one character of a file name, except for the separator character / and a . at the beginning of a file name. ? only matches an actual file name character and does not match nonexistent characters at the end of the file name. ? is analogous to the metacharacter . in regular expressions.

*

Matches zero or more characters in a file name, subject to the same restrictions as ?. * is analogous to the regular expression .*.

[chars]

Defines a class of characters; the glob pattern matches any single character in the class. A class can contain a range of characters by writing the first character in the range, a dash -, and the last character. For example, [A-Za-z], in the POSIX locale, stands for all the uppercase and lowercase letters. If you want a literal - character in the class, put it as the first or last character inside the brackets. If the first character inside the brackets is an exclamation mark (!), the pattern matches any single character that is not in the class.

Some sample patterns are:

[!a-f]*.c

Matches all .c files beginning with something other than the letters from a through f.

/???/?.?

Matches all files that are under the root directory in a directory with a three-letter name, and that have a basename containing one character followed by a . followed by another single character.

*/*.[chyl]

Matches all .c, .h, .y, and .l files in a subdirectory of the working directory.

~mks/*.ksh

Matches all shell scripts in the home directory of user mks (see Directory Substitution for the use of ~).

A variable name must begin with an uppercase or lowercase letter or an underscore (_). Subsequent characters in the name, if any, can be uppercase or lowercase letters, underscores, or digits 0 through 9. You can assign a value to a variable with:

variable=value

You can implicitly declare a variable as an array by using a subscript expression when assigning a value, as in:

variable[arithmetic expression]=value

A shell execution environment is the set of conditions affecting most commands run within the shell. It consists of:

• Open files
• The working directory (see cd)
• The file creation mask (see umask)
• The traps currently set (see trap)
• The shell parameters (see set and export)
• The shell functions currently defined (see Command Execution)
• Options (see set)

Shell utilities also run in a separate environment that does not affect the shell environment, except for certain built-in utilities (for example, cd and umask) that explicitly alter the shell environment. The environment of a shell utility is set up by the shell to include the following:

• Open files, subject to redirection.
• Working directory (see cd).
• File creation mask (see umask).
• Traps; traps caught by the shell are set to default values and traps ignored by the shell are ignored by the utility.
• Variables defined inside the shell and having the export attribute.

sh uses the following localization environment variables:

• LANG
• LC_ALL
• LC_COLLATE
• LC_CTYPE
• LC_MESSAGES

See Localization for more information.

Possible exit status values are:

0

Successful completion.

1

Failure due to any of the following:

• The shell was invoked with an incorrect option.
• The shell was invoked to run a shell script and the command.
• A command syntax error.
• A redirection error.
• A variable expansion error.