Bourne Shell Commands

When you issue a command in the Bourne shell, it first evaluates the command and makes all indicated substitutions. It then runs the command provided that:

• The command name is a Bourne shell special built-in command

  OR

• The command name matches the name of a defined function. If this is the case, the shell sets the positional parameters to the parameters of the function.

If the command name matches neither a built-in command nor the name of a defined function and the command names an executable file that is a compiled (binary) program, the shell (as parent) spawns a new (child) process that immediately runs the program. If the file is marked executable but is not a compiled program, the shell assumes that it is a shell procedure. In this case, the shell spawns another instance of itself (a subshell), to read the file and execute the commands included in it. The shell also runs a parenthesized command in a subshell. To the end user, a compiled program is run in exactly the same way as a shell procedure. The shell normally searches for commands in file system directories, in this order:

1. /usr/bin
2. /etc
3. /usr/sbin
4. /usr/ucb
5. $HOME/bin
6. /usr/bin/X11
7. /sbin
8. Current directory

The shell searches each directory, in turn, continuing with the next directory if it fails to find the command.

Note: The order in which the shell searches directories is determined by the PATH variable. You can change the particular sequence of directories searched by resetting the PATH variable.

If you give a specific path name when you run a command (for example, /usr/bin/sort), the shell does not search any directories other than the one you specify. If the command name contains a / (slash), the shell does not use the search path.

You can give a full path name that begins with the root directory (such as /usr/bin/sort). You can also specify a path name relative to the current directory. If you specify, for example:

bin/myfile

the shell looks in the current directory for a directory named bin and in that directory for the file myfile.

Note: The restricted shell does not run commands containing a / (slash).

The shell remembers the location in the search path of each executed command (to avoid unnecessary exec commands later). If it finds the command in a relative directory (one whose name does not begin with /), the shell must redetermine the command's location whenever the current directory changes. The shell forgets all remembered locations each time you change the PATH variable or run the hash -r command.

This section discusses:

• Quoting Characters
• Signal Handling
• Bourne Shell Built-in Commands
• Command Substitution in the Bourne Shell
• Bourne Shell Related Information

Quoting Characters

Many characters have a special meaning to the shell. Sometimes you want to conceal that meaning. Single (') and double (") quotation marks surrounding a string, or a backslash (\) before a single character allow you to conceal the character's meaning.

All characters, except the enclosing single quotation marks, are taken literally, with any special meaning removed. Thus, the command:

stuff='echo $? $*; ls * | wc'

assigns the literal string echo $? $*; ls * | wc to the variable stuff. The shell does not execute the echo, ls, and wc commands or expand the $? and $* variables and the * (asterisk) special character.

Within double quotation marks, the special meaning of the $ (dollar sign), ` (backquote), and " (double quotation) characters remains in effect, while all other characters are taken literally. Thus, within double quotation marks, command and variable substitution takes place. In addition, the quotation marks do not affect the commands within a command substitution that is part of the quoted string, so characters there retain their special meanings.

Consider the following sequence:

ls *

file1 file2 file3

message="This directory contains `ls * ` " 

echo $message

This directory contains file1 file2 file3

This shows that the * (asterisk) special character inside the command substitution was expanded.

To hide the special meaning of the $ (dollar sign), ` (backquote ), and " (double quotation) characters within double quotation marks, precede these characters with a \ (backslash). When you do not use double quotation marks, preceding a character with a backslash is equivalent to placing it within single quotation marks. Hence, a backslash immediately preceding a new-line character (that is, a backslash at the end of the line) hides the new-line character and allows you to continue the command line on the next physical line.

Signal Handling

The shell ignores INTERRUPT and QUIT signals for an invoked command if the command is terminated with an & (ampersand); that is, if it is running in the background. Otherwise, signals have the values inherited by the shell from its parent, with the exception of the SEGMENTATION VIOLATION signal. For more information, refer to the Bourne shell built-in trap command.

Bourne Shell Compound Commands

A compound command is one of the following:

• Pipeline (one or more simple commands separated by the | (pipe) symbol)
• List of simple commands
• Command beginning with a reserved word
• Command beginning with the control operator ( (left parenthesis).

Unless otherwise stated, the value returned by a compound command is that of the last simple command executed.

Reserved Words

The following reserved words are recognized only when they appear without quotes as the first word of a command:

for            do              done
case           esac
if             then             fi
elif           else
while          until
{              }
(              )

Bourne Shell Built-In Commands

Special commands are built in to the Bourne shell and run in the shell process. Unless otherwise indicated, output is written to file descriptor 1 (stdout) and the exit status is 0 (zero) if the command does not contain any syntax errors. Input and output redirection is permitted.

Refer to the List of Bourne Shell Built-in Commands for an alphabetical listing of these commands.

The following special commands are treated somewhat differently from other special built-in commands:

: (colon)     exec            shift
. (dot)       exit            times
break         export          trap
continue      readonly        wait
eval          return

The Bourne shell processes these commands as follows:

• Keyword parameter assignment lists preceding the command remain in effect when the command completes.
• I/O redirections are processed after parameter assignments.
• Errors in a shell script cause the script to stop processing.

Special Command Descriptions

The Bourne shell provides the following special built-in commands:

Hits   Cost   Command

Command Substitution in the Bourne Shell

Command substitution allows you to capture the output of any command as an argument to another command. When you place a command line within `` (backquotes), the shell first runs the command or commands, and then replaces the entire expression, including the backquotes, with the output. This feature is often used to give values to shell variables. For example, the statement:

today=`date`

assigns the string representing the current date to the today variable. The following assignment saves, in the files variable, the number of files in the current directory:

files=`ls | wc -l`

You can perform command substitution on any command that writes to standard output.

To nest command substitutions, precede each of the nested backquotes with a \ (backslash), as in:

logmsg=`echo Your login directory is \`pwd\``

You can also give values to shell variables indirectly by using the read special command. This command takes a line from standard input (usually your keyboard) and assigns consecutive words on that line to any variables named. For example:

read first init last

takes an input line of the form:

J. Q. Public

and has the same effect as if you had typed:

first=J. init=Q. last=Public

The read special command assigns any excess words to the last variable.