ksh.man

一个开放源代码的 AT&T 的 Korn Shell 的复制品, 支持大多数 ksh89 的特性。

'\" t
.\"{{{}}}
.\"{{{  Notes about man page
.\"     - use the pseudo-macros .sh( and .sh) to begin and end sh-specific
.\"       text and .ksh( and .ksh) for ksh specific text.
.\"     - put i.e., e.g. and etc. in italics
.\"}}}
.\"{{{  To do
.\" todo: Things not covered that should be:
.\"	- distinguish (POSIX) special built-in's, (POSIX) regular built-in's,
.\"	  and sh/ksh weirdo built-in's (put S,R,X superscripts after command
.\"	  name in built-in commands section?)
.\"	- need to be consistent about notation for `See section-name', `
.\"	  See description of foobar command', `See section section-name', etc.
.\"	- need to use the term `external command' meaning `a command that is 
.\"       executed using execve(2)' (as opposed to a built-in command or 
.\"       function) for more clear description.
.\"}}}
.\"{{{  Title
.ksh(
.TH KSH 1 "August 19, 1996" "" "User commands"
.ksh)
.sh(
.TH SH 1 "August 19, 1996" "" "User commands"
.sh)
.\"}}}
.\"{{{  Name
.SH NAME
.ksh(
ksh \- Public domain Korn shell
.ksh)
.sh(
sh \- Public domain Bourne shell
.sh)
.\"}}}
.\"{{{  Synopsis
.SH SYNOPSIS
.ad l
.ksh(
\fBksh\fP
.ksh)
.sh(
\fBsh\fP
.sh)
[\fB\(+-abCefhikmnprsuvxX\fP] [\fB\(+-o\fP \fIoption\fP] [ [ \fB\-c\fP \fIcommand-string\fP [\fIcommand-name\fP] | \fB\-s\fP | \fIfile\fP ] [\fIargument\fP ...] ]
.ad b
.\"}}}
.\"{{{  Description
.SH DESCRIPTION
.ksh(
\fBksh\fP is a command interpreter that is intended for both 
interactive and shell script use.  Its command language is a superset
of the \fIsh\fP(1) shell language.
.ksh)
.sh(
\fBsh\fP is a reimplementation of the Bourne shell, a command
interpreter for both interactive and script use.
.sh)
.\"{{{  Shell Startup
.SS "Shell Startup"
The following options can be specified only on the command line:
.IP "\fB\-c\fP \fIcommand-string\fP"
the shell executes the command(s) contained in \fIcommand-string\fP
.IP \fB\-i\fP
interactive mode \(em see below
.IP \fB\-l\fP
login shell \(em see below
interactive mode \(em see below
.IP \fB\-s\fP
the shell reads commands from standard input; all non-option arguments
are positional parameters
.IP \fB\-r\fP
restricted mode \(em see below
.PP
In addition to the above, the options described in the \fBset\fP built-in
command can also be used on the command line.
.PP
If neither the \fB\-c\fP nor the \fB\-s\fP options are specified, the
first non-option argument specifies the name of a file the shell reads
commands from; if there are no non-option arguments, the shell reads
commands from standard input.
The name of the shell (\fIi.e.\fP, the contents of the \fB$0\fP) parameter
is determined as follows: if the \fB\-c\fP option is used and there is
a non-option argument, it is used as the name; if commands are being
read from a file, the file is used as the name; otherwise the name
the shell was called with (\fIi.e.\fP, argv[0]) is used.
.PP
A shell is \fBinteractive\fP if the \fB\-i\fP option is used or
if both standard input and standard error are attached to a tty.
An interactive shell has job control enabled (if available),
ignores the INT, QUIT and TERM signals, and prints prompts before
reading input (see \fBPS1\fP and \fBPS2\fP parameters).
For non-interactive shells, the \fBtrackall\fP option is on by default
(see \fBset\fP command below).
.PP
A shell is \fBrestricted\fP if the \fB\-r\fP option is used or if either
the basename of the name the shell is invoked with or the \fBSHELL\fP
parameter match the pattern *r*sh (\fIe.g.\fP, rsh, rksh, rpdksh, \fIetc.\fP).
The following restrictions come into effect after the shell processes
any profile and \fB$ENV\fP files:
.nr P2 \n(PD
.nr PD 0
.IP \ \ \(bu
the \fBcd\fP command is disabled
.IP \ \ \(bu
the \fBSHELL\fP, \fBENV\fP and \fBPATH\fP parameters can't be changed
.IP \ \ \(bu
command names can't be specified with absolute or relative paths
.IP \ \ \(bu
the \fB\-p\fP option of the \fBcommand\fP built-in can't be used
.IP \ \ \(bu
redirections that create files can't be used (\fIi.e.\fP, \fB>\fP,
\fB>|\fP, \fB>>\fP, \fB<>\fP)
.nr PD \n(P2
.PP
A shell is \fBprivileged\fP if the \fB\-p\fP option is used or if
the real user-id or group-id does not match the effective user-id
or group-id (see \fIgetuid\fP(2), \fIgetgid\fP(2)).
A privileged shell does not process $HOME/.profile nor the \fBENV\fP
parameter (see below), instead the file /etc/suid_profile is processed.
Clearing the privileged option causes the shell to set its effective
user-id (group-id) to its real user-id (group-id).
.PP
If the basename of the name the shell is called with (\fIi.e.\fP, argv[0])
starts with \fB\-\fP or if the \fB\-l\fP option is used, the shell is assumed
to be a login shell and the shell reads and executes the contents of
\fB/etc/profile\fP and \fB$HOME/.profile\fP if they exist and are readable.
.PP
If the \fBENV\fP parameter is set when the shell starts (or, in the
case of login shells, after any profiles are processed), its value
is subjected to parameter, command, arithmetic and tilde substitution and
the resulting file (if any) is read and executed.
If \fBENV\fP parameter is not set (and not null) and pdksh was compiled
with the \fBDEFAULT_ENV\fP macro defined, the file named in that macro
is included (after the above mentioned substitutions have been performed).
.PP
The exit status of the shell is 127 if the command file specified
on the command line could not be opened, or non-zero if a fatal syntax
error occurred during the execution of a script.
In the absence of fatal errors, the exit status is that of the last
command executed, or zero, if no command is executed.
.\"}}}
.\"{{{  Command Syntax
.SS "Command Syntax"
.\"{{{  words and tokens
The shell begins parsing its input by breaking it into \fIword\fPs.
Words, which are sequences of characters, are delimited by unquoted
\fIwhite-space\fP characters (space, tab and newline) or \fImeta-characters\fP
(\fB<\fP, \fB>\fP, \fB|\fP, \fB;\fP, \fB&\fP, \fB(\fP and \fB)\fP).
Aside from delimiting words, spaces and tabs are ignored, while
newlines usually delimit commands.
The meta-characters are used in building the following tokens:
\fB<\fP, \fB<&\fP, \fB<<\fP, \fB>\fP, \fB>&\fP, \fB>>\fP, \fIetc.\fP are
used to specify redirections (see Input/Output Redirection below);
\fB|\fP is used to create pipelines;
.ksh(
\fB|&\fP is used to create co-processes (see Co-Processes below);
.ksh)
\fB;\fP is used to separate commands;
\fB&\fP is used to create asynchronous pipelines;
\fB&&\fP and \fB||\fP are used to specify conditional execution;
\fB;;\fP is used in \fBcase\fP statements;
.ksh(
\fB((\fP .. \fB))\fP are used in arithmetic expressions;
.ksh)
and lastly,
\fB(\fP .. \fB)\fP are used to create subshells.
.PP
White-space and meta-characters can be quoted individually using
backslash (\fB\e\fP), or in groups using double (\fB"\fP) or single (\fB'\fP)
quotes.
Note that the following characters are also treated specially by the shell and
must be quoted if they are to represent themselves:
\fB\e\fP, \fB"\fP, \fB'\fP, \fB#\fP, \fB$\fP, \fB`\fP, \fB~\fP, \fB{\fP,
\fB}\fP, \fB*\fP, \fB?\fP and \fB[\fP.
The first three of these are the above mentioned quoting characters
(see Quoting below);
\fB#\fP, if used at the beginning of a word, introduces a comment \(em everything
after the \fB#\fP up to the nearest newline is ignored;
\fB$\fP is used to introduce parameter, command and arithmetic substitutions
(see Substitution below);
\fB`\fP introduces an old-style command substitution
(see Substitution below);
\fB~\fP begins a directory expansion (see Tilde Expansion below);
\fB{\fP and \fB}\fP delimit \fIcsh\fP(1) style alternations
(see Brace Expansion below);
and, finally, \fB*\fP, \fB?\fP and \fB[\fP are used in file name generation
(see File Name Patterns below).
.\"}}}
.\"{{{  simple-command
.PP
As words and tokens are parsed, the shell builds commands, of which
there are two basic types: \fIsimple-commands\fP, typically programs
that are executed, and \fIcompound-commands\fP, such as \fBfor\fP and
\fBif\fP statements, grouping constructs and function definitions.
.PP
A simple-command consists of some combination of parameter assignments (see
Parameters below), input/output redirections (see Input/Output Redirections
below), and command words; the only restriction is that parameter assignments
come before any command words.
The command words, if any, define the command that is to be executed and its
arguments.
The command may be a shell built-in command, a function or an \fIexternal
command\fP, \fIi.e.\fP, a separate executable file that is located using the
\fBPATH\fP parameter (see Command Execution below).
Note that all command constructs have an \fIexit status\fP: for external
commands, this is related to the status returned by \fIwait\fP(2) (if the
command could not be found, the exit status is 127, if it could not be
executed, the exit status is 126);
the exit status of other command constructs (built-in commands, functions,
compound-commands, pipelines, lists, \fIetc.\fP) are all well defined and are
described where the construct is described.
The exit status of a command consisting only of parameter assignments is that
of the last command substitution performed during the parameter assignment
or zero if there were no command substitutions.
.\"}}}
.\"{{{  pipeline
.PP
Commands can be chained together using the \fB|\fP token to
form \fIpipelines\fP, in which the standard output of each command but
the last is piped (see \fIpipe\fP(2)) to the standard input of the following
command.
The exit status of a pipeline is that of its last command.
A pipeline may be prefixed by the \fB!\fP reserved word which
causes the exit status of the pipeline to be logically
complemented: if the original status was 0 the complemented status will
be 1, and if the original status was not 0, then the complemented
status will be 0.
.\"}}}
.\"{{{  lists
.PP
\fILists\fP of commands can be created by separating pipelines by
any of the following tokens: \fB&&\fP, \fB||\fP, \fB&\fP, \fB|&\fP and \fB;\fP.
The first two are for conditional execution: \fIcmd1\fP \fB&&\fP \fIcmd2\fP
executes \fIcmd2\fP only if the exit status of \fIcmd1\fP is zero;
\fB||\fP is the opposite \(em \fIcmd2\fP is executed only if the exit status
of \fIcmd1\fP is non-zero.
\fB&&\fP and \fB||\fP have equal precedence which is higher than that of
\fB&\fP, \fB|&\fP and \fB;\fP, which also have equal precedence.
The \fB&\fP token causes the preceding command to be executed asynchronously,
that is, the shell starts the command, but does not wait for it to complete
(the shell does keep track of the status of asynchronous commands \(em see
Job Control below).
When an asynchronous command is started when job control is disabled
(\fIi.e.\fP, in most scripts), the command is started with signals INT
and QUIT ignored and with input redirected from /dev/null
(however, redirections specified in the asynchronous command have precedence).
.ksh(
The \fB|&\fP operator starts a \fIco-process\fP which is special kind of
asynchronous process (see Co-Processes below).
.ksh)
Note that a command must follow the \fB&&\fP and \fB||\fP operators, while
a command need not follow \fB&\fP, \fB|&\fP and \fB;\fP.
The exit status of a list is that of the last command executed, with the
exception of asynchronous lists, for which the exit status is 0.
.\"}}}
.\"{{{  compound-commands
.PP
Compound commands are created using the following reserved words \(em these
words are only recognized if they are unquoted and if they are used as
the first word of a command (\fIi.e.\fP, they can't be preceded by parameter
assignments or redirections):
.TS
center;
lfB lfB lfB lfB lfB .
case	else	function	then	!
do	esac	if	time	[[
done	fi	in	until	{
elif	for	select	while	}
.TE
\fBNote:\fP Some shells (but not this one) execute control structure commands
in a subshell when one or more of their file descriptors are redirected, so
any environment changes inside them may fail.
To be portable, the \fBexec\fP statement should be used instead to redirect
file descriptors before the control structure.
.PP
In the following compound command descriptions, command lists (denoted as
\fIlist\fP) that are followed by reserved words must end with a
semi-colon, a newline or a (syntactically correct) reserved word.
For example,
.RS
\fB{ echo foo; echo bar; }\fP
.br
\fB{ echo foo; echo bar<newline>}\fP
.br
\fB{ { echo foo; echo bar; } }\fP
.RE
are all valid, but
.RS
\fB{ echo foo; echo bar }\fP
.RE
is not.
.\"{{{  ( list )
.IP "\fB(\fP \fIlist\fP \fB)\fP"
Execute \fIlist\fP in a subshell.  There is no implicit way to pass
environment changes from a subshell back to its parent.
.\"}}}
.\"{{{  { list }
.IP "\fB{\fP \fIlist\fP \fB}\fP"
Compound construct; \fIlist\fP is executed, but not in a subshell.
Note that \fB{\fP and \fB}\fP are reserved words, not meta-characters.
.\"}}}
.\"{{{  case word in [ [ ( ] pattern [ | pattern ] ... ) list ;; ] ... esac
.IP "\fBcase\fP \fIword\fP \fBin\fP [ [\fB(\fP] \fIpattern\fP [\fB|\fP \fIpattern\fP] ... \fB)\fP \fIlist\fP \fB;;\fP ] ... \fBesac\fP"
The \fBcase\fP statement attempts to match \fIword\fP against the specified
\fIpattern\fPs; the \fIlist\fP associated with the first successfully matched
pattern is executed.  Patterns used in \fBcase\fP statements are the same as
those used for file name patterns except that the restrictions regarding
\fB\&.\fP and \fB/\fP are dropped.  Note that any unquoted space before and
after a pattern is stripped; any space with a pattern must be quoted.  Both the
word and the patterns are subject to parameter, command, and arithmetic
substitution as well as tilde substitution.
For historical reasons, open and close braces may be used instead