sh - Invoke a shell

• Options and invocations
• Options
• Command syntax
• Reserved word commands
• Command execution
• Quoting
• Directory substitution
• Parameter substitution
• Arithmetic substitution
• File description and redirection
• File name generation
• Variables
• Shell variables
• Shell variables for automatic conversion
• Shell execution environments
• Built-in commands
• Shell archives
• Files
• Localization
• Exit values
• Messages
• Limits
• Portability
• Related information

.profile

-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 keyboard interrupts. Without -i, an interrupt ends the shell. For shells that read from the terminal, -i is the default.

-L

Makes the shell a login shell,. (A login shell is an interactive shell.)

-r

Invokes a restricted shell. (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 be run.

-S

Searches the directories in the environment variable PATH for a file cmd_file that contains shell commands. The current working directory is not searched before PATH.

• If -S is specified, the shell searches for the file in PATH. Only a file with executable access permissions for the user will be found in the PATH search.
• If -S is not specified, the shell searches for the file in the current working directory, then in PATH. The file must have read access that is permitted for the user. Executable access permission is not necessary.

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

command:

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

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

(command)

Runs command in a child shell. 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 child shell's environment begins as a copy of the current environment, so the value of the ENV environment variable is not run when achild shell 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, coprocesses should be designed to be used as coprocesses. On systems where asynchronous execution is not possible, coprocesses 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 exclamation point is the logical NOT command. When its operand is false (nonzero), this command returns true (zero). When its operand is true (zero), this command 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 child shell. { and } are 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 }.

[[ test_expr ]]

The double-square-bracket command ([[ test_expr ]]) is a command that returns an exit status indicating whether the test_expr (test expression) is true or false.

Word-splitting and wildcard expansion (file name expansion or globbing) are not done within [[ ]]. This makes quoting less necessary than when you use the test (or [ ]) command. Alias expansion is also not done within [[ ]].

The following primitives are used in ([[ test_expr ]]). Spaces or tabs are required to separate operators from operands.

-a file

True if file exists (-e is recommended to avoid confusion with the test command syntax)

-Aa file

True if file has an extended access ACL entry.

-Ad file

True if file has a directory default ACL.

-Af file

True if file has a file default ACL.

-b file

True if file is a block special file (block special files are not supported in z/OS)

-B file

True if the file is tagged as binary (not text)

-c file

True if file is a character special file

-d file

True if file is a directory

-e file

True if file exists

-Ea file

True if the file has the APF extended attribute

-El file

True if the file has the shared library extended attribute

-Ep file

True if the file has the program control extended attribute

-Es file

True if the file has the shared address space extended attribute

-f file

True if file is an ordinary file

-g file

True if the set-group-ID attribute of file is on

-G file

True if file group owner is the effective group ID

-h file

True if file is a symbolic link

-k file

True if file has the "sticky" bit on

-L file

True if file is a symbolic link

-Ma file

True if the file has a security label

-n string

True if the length of the string is greater than zero

-o option

True if shell option is on

-O file

True if file owner is the effective user ID

-p file

True if file is a FIFO (named pipe)

-r file

True if file is readable (checks permission bits and access control)

-s file

True if size of the file is nonzero

-S file

True if file is a socket

-t fd

True if the numeric file descriptor fd is open and associated with a terminal

-T file

True if the file is tagged as text

-u file

True if the set-user-ID attribute of file is on

-w file

True if file is writable (checks permission bits and access control)

-x file

True if file is executable (checks permission bits and access control)

-z string

True if length of the string is zero

string

True if string is not a null string

string = pattern

True if string matches pattern (== is recommended to avoid confusion with the test command syntax)

string == pattern

True if string matches pattern. Quote pattern to treat it as a string. For information about patterns, see File name generation.

string1 != pattern

True if string does not match patterns. For information about patterns, see File name generation.

string1 < string2

True if string1 comes before string2 in the collation order defined in the current locale

string1 > string2

True if string1 comes after string2 in the collation order defined in the current locale

exp1 -eq exp2

True if arithmetic expression exp1 and exp2 are equal

exp1 -ge exp2

True if arithmetic expression exp1 is greater than or equal to exp2

exp1 -gt exp2

True if arithmetic expression exp1 is greater than exp2

exp1 -le exp2

True if arithmetic expression exp1 is less than or equal to exp2

exp1 -lt exp2

True if arithmetic expression exp1 is less than exp2

exp1 -ne exp2

True if arithmetic expression exp1 is not equal to exp2

file1 -nt file2

True if file1 is newer than file2

file1 -ot file2

True if file1 is older than file2

file1 -ef file2

True if file1 is a hard link or symbolic link to file2 (this is different than the test command which only tests for hard links on z/OS)

file-CS codeset

True if the file is tagged with the codeset

file -Ml seclabel

True if the file has a security label. False if the file does not have a security label that matches the specified seclabel.

( test_expr )

Grouping to override normal precedence; true if test_expr is true

! test_expr

Logical negation; true if test_expr is false

test_expr1 && test_expr2

Logical AND; true if both test_expr1 and test_expr2 are true

test_expr || test_expr2

Logical OR; true if either test_expr1 or test_expr2 is true

Patterns tested in double-square-bracket conditions are composed of special characters and regular characters. Patterns follow the rules given in File name generation, except that the period (.) and the slash (/) are not treated specially. Note that pattern matching is similar to regular expression processing, but different in syntax.

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 double quotation marks 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 ... }

Either 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, as well as any flags manipulated by EXIT 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 menu-like 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).

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

• 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. If the FPATH shell variable is set, the shell will search the PATH and FPATH directories. If a file with a name matching the command name is found in the same directory in both PATH and FPATH, or if a matching file is found only in FPATH, this file will be read and executed in the current shell environment (defining the functions contained in the file). The shell will then execute the function matching the command name. This allows users to use FPATH for locating functions without the need to identify every function with the autoload command.

  If FPATH is not set, or if the command is not found in FPATH, the shell executes the first matching file found in the PATH directories. For more information about specifying the PATH variable when customizing the search path for commands, see Customizing the search path for commands: The PATH variable in z/OS UNIX System Services User's Guide.

 echo
'*'

"time" program

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

*   ?   [   #   %   =
 ~

 ~jsmith/file

echo ~

*    @    #    ?    !    -    $     0

echo $x

$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 (see 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 process ID of the shell. If running in a child shell environment (see Shell execution environments), it is the process ID of the parent shell. Otherwise, it is the process ID of the current shell.

$!

Expands to the process number of the last asynchronous command.

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

${# *}

Expands to the number of positional parameters.

${#@}

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 non-interactive 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 non-empty.

${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 expression))

$[arithmetic expression]

• A number that starts with 0x is hexadecimal.
• A number that starts with 0 is octal.
• A number that does not start with 0x or 0 is decimal.
• base #number, where base is a decimal integer between 2 and 36 inclusive, and number is any nonnegative number in the given base.

• In assignment to an integer variable. (See typeset.)
• As an argument to the following built-in shell commands:

  break          exit         return continue       let          shift

• When used as arguments in the test built-in shell command numeric comparisons (-eq, -ge, -gt, -le, -lt, and -ne). See test.

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

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 does not 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 does not 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 in "name" any part (empty or not) is quoted or any character escaped, does not perform substitutions on the input; otherwise, 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 standard input.

number1>&number2

Makes the output file descriptor number1 a duplicate of file descriptor number2. If you omit number1, 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 standard output has the same effect as writing output on 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.

?

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 (or other glob character) in the class, use the backslash to escape the character, causing it to lose its special meaning within the pattern expression. If the first character inside the brackets is an exclamation mark (!), the pattern matches any single character that is not in the class.

[!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

variable=value

variable[arithmetic expression]=value

• 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)

• 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 command.
• Variables defined inside the shell and having the export attribute.

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

• autoload
• hash
• functions
• integer
• history
• r
• nohup
• suspend
• stop

# This is a shell archive.
# It contains the one file "frag.ksh"
# To extract contents, type
# sh file
#
if      [ -f frag.ksh ]
then    echo frag.ksh exists: will not overwrite
else
    echo extracting frag.ksh
    sed 's/^X//' >frag.ksh <<_EOF_
X# This is frag.ksh
X# Not very interesting, really.
Xecho frag.ksh here!
_EOF_
    if [ "`sum frag.ksh|awk '{print $1{'`" != 52575 ]
    then        echo frag.ksh damaged in transit
    fi
fi

# Print out Fibonacci sequence; start sequence
# with first two positional parameters:
# default 1 1
typeset -i x=${1:-1{ y=${2:-1} z
while   [ x -gt 0 ]     # until overflow
do
        echo $x
        let z=y+x x=y y=z
done

# basename command as shell function
function basename {
        case $# in
        1)      ;;
        2)      eval set \${1%$2} ;;
        *)      echo Usage:       $0 pathname '[suffix]     '
                return 1 ;;
        esac
        echo ${1##*/}
        return 0
}

• LANG
• LC_ALL
• LC_COLLATE
• LC_CTYPE
• LC_MESSAGES
• LC_SYNTAX