5365 lines
129 KiB
Plaintext
5365 lines
129 KiB
Plaintext
.\" $MirBSD: src/bin/ksh/ksh.1tbl,v 2.10 2004/12/31 19:00:30 tg Exp $
|
|
.\" $OpenBSD: ksh.1tbl,v 1.84 2004/12/22 18:58:44 millert Exp $
|
|
.\" $OpenBSD: sh.1tbl,v 1.53 2004/12/10 01:56:56 jaredy Exp $
|
|
.\"
|
|
.\" Public Domain.
|
|
.\"
|
|
.Dd November 10, 2004
|
|
.Dt KSH 1
|
|
.Os MirOS
|
|
.\" define Mx macro for portable mksh, just in case...
|
|
.de Mx
|
|
.nr cF \\n(.f
|
|
.nr cZ \\n(.s
|
|
.ds aa \&\f\\n(cF\s\\n(cZ
|
|
.if \\n(aC==0 \{\
|
|
. if \\n(.$==0 \&MirOS\\*(aa
|
|
.\}
|
|
.if \\n(.$==1 \{\
|
|
. if "\\$1"6" \&MirOS #6\\*(aa
|
|
. if "\\$1"." \&MirOS\\$1\\*(aa
|
|
. if "\\$1"," \&MirOS\\$1\\*(aa
|
|
. if "\\$1"MirBSD" \&MirBSD\\*(aa
|
|
.\}
|
|
..
|
|
.Sh NAME
|
|
.Nm ksh ,
|
|
.Nm sh ,
|
|
.Nm mksh
|
|
.Nd MirBSD Korn/Bourne shell
|
|
.Sh SYNOPSIS
|
|
.Nm
|
|
.Op Fl +abCefhiklmnprsuvxX
|
|
.Op Fl T Ar /dev/ttyCn
|
|
.Op Fl +o Ar option
|
|
.Xo
|
|
.Bk -words
|
|
.Oo Oo Fl c Ar command-string
|
|
.Op Ar command-name
|
|
.Li \&| Fl s
|
|
.Li \&| Ar file Oc
|
|
.Ek
|
|
.Op Ar argument ... Oc
|
|
.Xc
|
|
.Sh DESCRIPTION
|
|
.Nm
|
|
is a command interpreter intended for both interactive and shell
|
|
script use.
|
|
Its command language is a superset of the
|
|
.Xr sh C
|
|
shell language and compatible to the original Korn shell.
|
|
.Nm mksh
|
|
is derived from
|
|
.Nm pdksh ,
|
|
the public domain Korn shell.
|
|
.Ss Shell startup
|
|
The following options can be specified only on the command line:
|
|
.Bl -tag -width Ds
|
|
.It Fl c Ar command-string
|
|
.Nm
|
|
will execute the command(s) contained in
|
|
.Ar command-string .
|
|
.It Fl i
|
|
Interactive mode; see below.
|
|
.It Fl l
|
|
Login shell; see below.
|
|
.It Fl s
|
|
The shell reads commands from standard input; all non-option arguments
|
|
are positional parameters.
|
|
.It Fl r
|
|
Restricted mode; see below.
|
|
.It Fl T Ar tty
|
|
Spawn
|
|
.Nm
|
|
on
|
|
.Xr tty 4
|
|
device given.
|
|
Superuser only.
|
|
.El
|
|
.Pp
|
|
In addition to the above, the options described in the
|
|
.Ic set
|
|
built-in command can also be used on the command line.
|
|
.Pp
|
|
If neither the
|
|
.Fl c
|
|
nor the
|
|
.Fl s
|
|
option is 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 the standard input.
|
|
The name of
|
|
the shell (i.e., the contents of
|
|
.Ic $0 )
|
|
is determined as follows: if the
|
|
.Fl c
|
|
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 (i.e.,
|
|
.Li argv[0] )
|
|
is used.
|
|
.Pp
|
|
A shell is
|
|
.Dq interactive
|
|
if the
|
|
.Fl i
|
|
option is used or if both standard input and standard error are attached to a
|
|
.Xr tty 4 .
|
|
An interactive shell has job control enabled (if available), ignores the
|
|
.Dv SIGINT ,
|
|
.Dv SIGQUIT
|
|
and
|
|
.Dv SIGTERM
|
|
signals and prints prompts before reading input (see
|
|
.Ev PS1
|
|
and
|
|
.Ev PS2
|
|
parameters).
|
|
For non-interactive shells, the
|
|
.Ic trackall
|
|
option is on by default (see the
|
|
.Ic set
|
|
command below).
|
|
.Pp
|
|
If the
|
|
.Fl T Ar ttydev
|
|
option is given, an interactive shell is spawned in the background
|
|
with the given device as controlling terminal.
|
|
The terminal devices are probed in the following order:
|
|
.Bl -enum -compact
|
|
.It
|
|
ttydev
|
|
.It
|
|
.Pa /dev/ttyC Ns ttydev
|
|
.It
|
|
.Pa /dev/tty Ns ttydev
|
|
.El
|
|
.Pp
|
|
A shell is
|
|
.Dq restricted
|
|
if the
|
|
.Fl r
|
|
option is used or if either the basename of the name the shell was invoked
|
|
with or the
|
|
.Ev SHELL
|
|
parameter match the pattern
|
|
.Dq \&*r\&*sh
|
|
(e.g.,
|
|
.Dq rsh ,
|
|
.Dq rmksh ,
|
|
.Dq rpdksh ,
|
|
etc.).
|
|
The following restrictions come into effect after the shell processes any
|
|
profile and
|
|
.Ev ENV
|
|
files:
|
|
.Pp
|
|
.Bl -bullet -compact
|
|
.It
|
|
The
|
|
.Ic cd
|
|
command is disabled.
|
|
.It
|
|
The
|
|
.Ev SHELL ,
|
|
.Ev ENV
|
|
and
|
|
.Ev PATH
|
|
parameters cannot be changed.
|
|
.It
|
|
Command names can't be specified with absolute or relative paths.
|
|
.It
|
|
The
|
|
.Fl p
|
|
option of the built-in command
|
|
.Ic command
|
|
can't be used.
|
|
.It
|
|
Redirections that create files can't be used (i.e.,
|
|
.Ql > ,
|
|
.Ql >| ,
|
|
.Ql >> ,
|
|
.Ql <> ) .
|
|
.El
|
|
.Pp
|
|
A shell is
|
|
.Dq privileged
|
|
if the
|
|
.Fl p
|
|
option is used or if the real user ID or group ID does not match the
|
|
effective user ID or group ID (see
|
|
.Xr getuid 2
|
|
and
|
|
.Xr getgid 2 ) .
|
|
A privileged shell does not process
|
|
.Pa $HOME/.profile
|
|
nor the
|
|
.Ev ENV
|
|
parameter (see below).
|
|
Instead, the file
|
|
.Pa /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 (i.e.,
|
|
.Li argv[0] )
|
|
starts with
|
|
.Ql -
|
|
or if the
|
|
.Fl l
|
|
option is used,
|
|
the shell is assumed to be a login shell and the shell reads and executes
|
|
the contents of
|
|
.Pa /etc/profile
|
|
and
|
|
.Pa $HOME/.profile
|
|
if they exist and are readable.
|
|
.Pp
|
|
If the
|
|
.Ev ENV
|
|
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
|
|
.Pq Sq \&~
|
|
substitution and the resulting file
|
|
(if any) is read and executed.
|
|
If the
|
|
.Ev ENV
|
|
parameter is not set (and not
|
|
.Dv NULL )
|
|
and
|
|
.Nm
|
|
was compiled with the non-default
|
|
.Dv DEFAULT_ENV
|
|
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.
|
|
.Ss Command syntax
|
|
The shell begins parsing its input by breaking it into
|
|
.Em words .
|
|
Words, which are sequences of characters, are delimited by unquoted whitespace
|
|
characters (space, tab and newline) or meta-characters
|
|
.Po
|
|
.Ql < ,
|
|
.Ql > ,
|
|
.Ql | ,
|
|
.Ql \&; ,
|
|
.Ql (
|
|
and
|
|
.Ql \&)
|
|
.Pc .
|
|
Aside from delimiting words, spaces and tabs are ignored, while newlines
|
|
usually delimit commands.
|
|
The meta-characters are used in building the following tokens:
|
|
.Ql < ,
|
|
.Ql <& ,
|
|
.Ql << ,
|
|
.Ql > ,
|
|
.Ql >& ,
|
|
.Ql >> ,
|
|
etc. are used to specify redirections (see
|
|
.Sx Input/output redirection
|
|
below);
|
|
.Ql |
|
|
is used to create pipelines;
|
|
.Ql |&
|
|
is used to create co-processes (see
|
|
.Sx Co-processes
|
|
below);
|
|
.Ql \&;
|
|
is used to separate commands;
|
|
.Ql &
|
|
is used to create asynchronous pipelines;
|
|
.Ql &&
|
|
and
|
|
.Ql ||
|
|
are used to specify conditional execution;
|
|
.Ql \&;\&;
|
|
is used in
|
|
.Ic case
|
|
statements;
|
|
.Ql \&(\&( .. \&)\&)
|
|
is used in arithmetic expressions;
|
|
and lastly,
|
|
.Ql \&( .. \&)
|
|
is used to create subshells.
|
|
.Pp
|
|
Whitespace and meta-characters can be quoted individually using a backslash
|
|
.Pq Sq \e
|
|
or in groups using double
|
|
.Pq Sq \&"
|
|
or single
|
|
.Pq Sq \&'
|
|
quotes.
|
|
Note that the following characters are also treated specially by the
|
|
shell and must be quoted if they are to represent themselves:
|
|
.Ql \e ,
|
|
.Ql \&" ,
|
|
.Ql ' ,
|
|
.Ql # ,
|
|
.Ql $ ,
|
|
.Ql ` ,
|
|
.Ql ~ ,
|
|
.Ql { ,
|
|
.Ql } ,
|
|
.Ql * ,
|
|
.Ql \&?
|
|
and
|
|
.Ql [ .
|
|
The first three of these are the above mentioned quoting characters (see
|
|
.Sx Quoting
|
|
below);
|
|
.Ql # ,
|
|
if used at the beginning of a word, introduces a comment \(em everything after
|
|
the
|
|
.Ql #
|
|
up to the nearest newline is ignored;
|
|
.Ql $
|
|
is used to introduce parameter, command and arithmetic substitutions (see
|
|
.Sx Substitution
|
|
below);
|
|
.Ql `
|
|
introduces an old-style command substitution (see
|
|
.Sx Substitution
|
|
below);
|
|
.Ql ~
|
|
begins a directory expansion (see
|
|
.Sx Tilde expansion
|
|
below);
|
|
.Ql {
|
|
and
|
|
.Ql }
|
|
delimit
|
|
.Xr csh 1
|
|
style alterations (see
|
|
.Sx Brace expansion
|
|
below);
|
|
and finally,
|
|
.Ql * ,
|
|
.Ql \&?
|
|
and
|
|
.Ql [
|
|
are used in file name generation (see
|
|
.Sx File name patterns
|
|
below).
|
|
.Pp
|
|
As words and tokens are parsed, the shell builds commands, of which there
|
|
are two basic types:
|
|
.Em simple-commands ,
|
|
typically programs that are executed, and
|
|
.Em compound-commands ,
|
|
such as
|
|
.Ic for
|
|
and
|
|
.Ic if
|
|
statements, grouping constructs and function definitions.
|
|
.Pp
|
|
A simple-command consists of some combination of parameter assignments
|
|
(see
|
|
.Sx Parameters
|
|
below),
|
|
input/output redirections (see
|
|
.Sx 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 external command (i.e., a separate executable file
|
|
that is located using the
|
|
.Ev PATH
|
|
parameter (see
|
|
.Sx Command execution
|
|
below)).
|
|
Note that all command constructs have an exit status: for external commands,
|
|
this is related to the status returned by
|
|
.Xr wait 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,
|
|
etc.) 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 0 is there were no command substitutions.
|
|
.Pp
|
|
Commands can be chained together using the
|
|
.Ql |
|
|
token to form pipelines, in which the standard output of each command but the
|
|
last is piped (see
|
|
.Xr pipe 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
|
|
.Ql \&!
|
|
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;
|
|
if the original status was not 0, the complemented status will be 0.
|
|
.Pp
|
|
.Em Lists
|
|
of commands can be created by separating pipelines by any of the following
|
|
tokens:
|
|
.Ql && ,
|
|
.Ql || ,
|
|
.Ql & ,
|
|
.Ql |&
|
|
and
|
|
.Ql \&; .
|
|
The first two are for conditional execution:
|
|
.Dq Ar cmd1 No && Ar cmd2
|
|
executes
|
|
.Ar cmd2
|
|
only if the exit status of
|
|
.Ar cmd1
|
|
is zero;
|
|
.Ql ||
|
|
is the opposite \(em
|
|
.Ar cmd2
|
|
is executed only if the exit status of
|
|
.Ar cmd1
|
|
is non-zero.
|
|
.Ql &&
|
|
and
|
|
.Ql ||
|
|
have equal precedence which is higher than that of
|
|
.Ql & ,
|
|
.Ql |&
|
|
and
|
|
.Ql \&; ,
|
|
which also have equal precedence.
|
|
Note that the
|
|
.Ql &&
|
|
and
|
|
.Ql ||
|
|
operators are
|
|
.Qq left-associative .
|
|
For example, both of these commands will print only
|
|
.Qq bar :
|
|
.Bd -literal -offset indent
|
|
false && echo foo || echo bar
|
|
true || echo foo && echo bar
|
|
.Ed
|
|
.Pp
|
|
The
|
|
.Ql &
|
|
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, see
|
|
.Sx Job control
|
|
below).
|
|
When an asynchronous command is started when job control is disabled
|
|
(i.e., in most scripts), the command is started with signals
|
|
.Dv SIGINT
|
|
and
|
|
.Dv SIGQUIT
|
|
ignored and with input redirected from
|
|
.Pa /dev/null
|
|
(however, redirections specified in the asynchronous command have precedence).
|
|
The
|
|
.Ql |&
|
|
operator starts a co-process which is a special kind of asynchronous process
|
|
(see
|
|
.Sx Co-processes
|
|
below).
|
|
Note that a command must follow the
|
|
.Ql &&
|
|
and
|
|
.Ql ||
|
|
operators, while it need not follow
|
|
.Ql & ,
|
|
.Ql |&
|
|
or
|
|
.Ql \&; .
|
|
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.
|
|
.Pp
|
|
Compound commands are created using the following reserved words.
|
|
These words
|
|
are only recognized if they are unquoted and if they are used as the first
|
|
word of a command (i.e., they can't be preceded by parameter assignments or
|
|
redirections):
|
|
.Bd -literal -offset center
|
|
case else function then !
|
|
do esac if time [[
|
|
done fi in until {
|
|
elif for select while }
|
|
.Ed
|
|
.Pp
|
|
.Sy Note:
|
|
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
|
|
.Ic exec
|
|
statement should be used instead to redirect file descriptors before the
|
|
control structure.
|
|
.Pp
|
|
In the following compound command descriptions, command lists (denoted as
|
|
.Em list )
|
|
that are followed by reserved words must end with a semicolon, a newline or
|
|
a (syntactically correct) reserved word.
|
|
For example,
|
|
.Bd -unfilled -offset indent
|
|
.Ic { echo foo; echo bar; }
|
|
.Ic { echo foo; echo bar<newline> }
|
|
.Ic { { echo foo; echo bar; } }
|
|
.Ed
|
|
.Pp
|
|
are all valid, but
|
|
.Bd -unfilled -offset indent
|
|
.Ic { echo foo; echo bar }
|
|
.Ed
|
|
.Pp
|
|
is not.
|
|
.Bl -tag -width Ds
|
|
.It Ic \&( Ar list Ic \&)
|
|
Execute
|
|
.Ar list
|
|
in a subshell.
|
|
There is no implicit way to pass environment changes from a
|
|
subshell back to its parent.
|
|
.It Ic \&{ Ar list Ic \&}
|
|
Compound construct;
|
|
.Ar list
|
|
is executed, but not in a subshell.
|
|
Note that
|
|
.Ic \&{
|
|
and
|
|
.Ic \&}
|
|
are reserved words, not meta-characters.
|
|
.It Xo Ic case Ar word Ic in [
|
|
.Ns [ Ic \&( ] Ar pattern [
|
|
.Ns Ic \&| Ar pattern ] ... Ic \&)
|
|
.Ar list Ic \&;\&;
|
|
.Ns ] Ar ...
|
|
.Ic esac
|
|
.Xc
|
|
The
|
|
.Ic case
|
|
statement attempts to match
|
|
.Ar word
|
|
against the specified
|
|
.Ar pattern Ns s ;
|
|
the
|
|
.Ar list
|
|
associated with the first successfully matched pattern is executed.
|
|
Patterns used in
|
|
.Ic case
|
|
statements are the same as those used for file name patterns except that the
|
|
restrictions regarding
|
|
.Ql \&.
|
|
and
|
|
.Ql /
|
|
are dropped.
|
|
Note that any unquoted space before and after a pattern is
|
|
stripped; any space within 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 of
|
|
.Ic in
|
|
and
|
|
.Ic esac
|
|
(e.g.,
|
|
.Ic case $foo { *) print bar; } ) .
|
|
The exit status of a
|
|
.Ic case
|
|
statement is that of the executed
|
|
.Ar list ;
|
|
if no
|
|
.Ar list
|
|
is executed, the exit status is zero.
|
|
.It Xo Ic for Ar name No [
|
|
.Ic in Ar word ... term Ns ]
|
|
.Ic do Ar list Ic done
|
|
.Xc
|
|
For each
|
|
.Ar word
|
|
in the specified word list, the parameter
|
|
.Ar name
|
|
is set to the word and
|
|
.Ar list
|
|
is executed.
|
|
If
|
|
.Ic in
|
|
is not used to specify a word list, the positional parameters
|
|
.Po
|
|
.Ic $1 , $2 ,
|
|
etc.\&
|
|
.Pc
|
|
are used instead.
|
|
For historical reasons, open and close braces may be used instead of
|
|
.Ic do
|
|
and
|
|
.Ic done
|
|
(e.g.,
|
|
.Ic for i\&; { print $i; } ) .
|
|
The exit status of a
|
|
.Ic for
|
|
statement is the last exit status of
|
|
.Ar list ;
|
|
if
|
|
.Ar list
|
|
is never executed, the exit status is zero.
|
|
.Ar term
|
|
is either a newline or a
|
|
.Ql \&; .
|
|
.It Xo Ic if Ar list Ic then
|
|
.Ar list [ Ic elif Ar list Ic then
|
|
.Ar list ] Ar ... [ Ic else
|
|
.Ar list ] Ic fi
|
|
.Xc
|
|
If the exit status of the first
|
|
.Ar list
|
|
is zero, the second
|
|
.Ar list
|
|
is executed; otherwise, the
|
|
.Ar list
|
|
following the
|
|
.Ic elif ,
|
|
if any, is executed with similar consequences.
|
|
If all the lists following the
|
|
.Ic if
|
|
and
|
|
.Ic elif Ns s
|
|
fail (i.e., exit with non-zero status), the
|
|
.Ar list
|
|
following the
|
|
.Ic else
|
|
is executed.
|
|
The exit status of an
|
|
.Ic if
|
|
statement is that of non-conditional
|
|
.Ar list
|
|
that is executed; if no non-conditional
|
|
.Ar list
|
|
is executed, the exit status is zero.
|
|
.It Xo Ic select Ar name No [
|
|
.Ic in Ar word ... term Ns ]
|
|
.Ic do Ar list Ic done
|
|
.Xc
|
|
The
|
|
.Ic select
|
|
statement provides an automatic method of presenting the user with a menu and
|
|
selecting from it.
|
|
An enumerated list of the specified
|
|
.Ar word Ns s
|
|
is printed on standard error, followed by a prompt
|
|
.Po
|
|
.Ev PS3, normally
|
|
.Dq #?\ \&
|
|
.Pc .
|
|
A number corresponding to one of the enumerated words is then read from
|
|
standard input,
|
|
.Ar name
|
|
is set to the selected word (or unset if the selection is not valid),
|
|
.Ev REPLY
|
|
is set to what was read (leading/trailing space is stripped) and
|
|
.Ar list
|
|
is executed.
|
|
If a blank line (i.e., zero or more
|
|
.Ev IFS
|
|
characters) is entered, the menu is reprinted without executing
|
|
.Ar list .
|
|
When
|
|
.Ar list
|
|
completes, the enumerated list is printed if
|
|
.Ev REPLY
|
|
is
|
|
.Dv NULL ,
|
|
the prompt is printed and so on.
|
|
This process continues until an end-of-file
|
|
is read, an interrupt is received or a
|
|
.Ic break
|
|
statement is executed inside the loop.
|
|
If
|
|
.Ic in Ar word ...\&
|
|
is omitted, the positional parameters are used (i.e.,
|
|
.Ic $1 , $2 ,
|
|
etc.).
|
|
For historical reasons, open and close braces may be used instead of
|
|
.Ic do
|
|
and
|
|
.Ic done
|
|
(e.g.,
|
|
.Ic select i; { print $i; } ) .
|
|
The exit status of a
|
|
.Ic select
|
|
statement is zero if a
|
|
.Ic break
|
|
statement is used to exit the loop, non-zero otherwise.
|
|
.It Xo Ic until Ar list Ic do Ar list
|
|
.Ic done
|
|
.Xc
|
|
This works like
|
|
.Ic while ,
|
|
except that the body is executed only while the exit status of the first
|
|
.Ar list
|
|
is non-zero.
|
|
.It Xo Ic while Ar list Ic do Ar list
|
|
.Ic done
|
|
.Xc
|
|
A
|
|
.Ic while
|
|
is a pre-checked loop.
|
|
Its body is executed as often as the exit status of the first
|
|
.Ar list
|
|
is zero.
|
|
The exit status of a
|
|
.Ic while
|
|
statement is the last exit status of the
|
|
.Ar list
|
|
in the body of the loop; if the body is not executed, the exit status is zero.
|
|
.It Xo Ic function Ar name Ic \&{
|
|
.Ar list Ic \&}
|
|
.Xc
|
|
Defines the function
|
|
.Ar name
|
|
(see
|
|
.Sx Functions
|
|
below).
|
|
Note that redirections specified after a function definition are
|
|
performed whenever the function is executed, not when the function definition
|
|
is executed.
|
|
.It Ar name Ic () Ar command
|
|
Mostly the same as
|
|
.Ic function
|
|
(see
|
|
.Sx Functions
|
|
below).
|
|
.It Xo Ic time Op Fl p
|
|
.Op Ar pipeline
|
|
.Xc
|
|
The
|
|
.Ic time
|
|
reserved word is described in the
|
|
.Sx Command execution
|
|
section.
|
|
.It Ic (( Ar expression Ic ))
|
|
The arithmetic expression
|
|
.Ar expression
|
|
is evaluated; equivalent to
|
|
.Ic let Ar expression
|
|
(see
|
|
.Sx Arithmetic expressions
|
|
and the
|
|
.Ic let
|
|
command below).
|
|
.It Ic [[ Ar expression Ic ]]
|
|
Similar to the
|
|
.Ic test
|
|
and
|
|
.Ic \&[ Ar ... Ic \&]
|
|
commands (described later), with the following exceptions:
|
|
.Bl -bullet -offset indent
|
|
.It
|
|
Field splitting and file name generation are not performed on arguments.
|
|
.It
|
|
The
|
|
.Fl a
|
|
.Pq Tn AND
|
|
and
|
|
.Fl o
|
|
.Pq Tn OR
|
|
operators are replaced with
|
|
.Ql &&
|
|
and
|
|
.Ql || ,
|
|
respectively.
|
|
.It
|
|
Operators (e.g.,
|
|
.Sq Fl f ,
|
|
.Sq = ,
|
|
.Sq \&! ,
|
|
etc.) must be unquoted.
|
|
.It
|
|
The second operand of the
|
|
.Sq !=
|
|
and
|
|
.Sq =
|
|
expressions are patterns (e.g., the comparison
|
|
.Ic [[ foobar = f*r ]]
|
|
succeeds).
|
|
.It
|
|
There are two additional binary operators:
|
|
.Ql <
|
|
and
|
|
.Ql >
|
|
which return true if their first string operand is less than, or greater than,
|
|
their second string operand, respectively.
|
|
.It
|
|
The single argument form of
|
|
.Ic test ,
|
|
which tests if the argument has a non-zero length, is not valid; explicit
|
|
operators must always be used (e.g., instead of
|
|
.Ic \&[ Ar str Ic \&]
|
|
use
|
|
.Ic \&[[ Fl n Ar str Ic \&]] ) .
|
|
.It
|
|
Parameter, command and arithmetic substitutions are performed as expressions
|
|
are evaluated and lazy expression evaluation is used for the
|
|
.Ql &&
|
|
and
|
|
.Ql ||
|
|
operators.
|
|
This means that in the statement
|
|
.Pp
|
|
.Dl Ic "[[ -r foo && $(<foo) = b*r ]]"
|
|
.Pp
|
|
the
|
|
.Ic $(<foo)
|
|
is evaluated if and only if the file
|
|
.Pa foo
|
|
exists and is readable.
|
|
.El
|
|
.El
|
|
.Ss Quoting
|
|
Quoting is used to prevent the shell from treating characters or words
|
|
specially.
|
|
There are three methods of quoting.
|
|
First,
|
|
.Ql \e
|
|
quotes the following character, unless it is at the end of a line, in which
|
|
case both the
|
|
.Ql \e
|
|
and the newline are stripped.
|
|
Second, a single quote
|
|
.Pq Sq '
|
|
quotes everything up to the next single quote (this may span lines).
|
|
Third, a double quote
|
|
.Pq Sq \&"
|
|
quotes all characters, except
|
|
.Ql $ ,
|
|
.Ql `
|
|
and
|
|
.Ql \e ,
|
|
up to the next unquoted double quote.
|
|
.Ql $
|
|
and
|
|
.Ql `
|
|
inside double quotes have their usual meaning (i.e., parameter, command or
|
|
arithmetic substitution) except no field splitting is carried out on the
|
|
results of double-quoted substitutions.
|
|
If a
|
|
.Ql \e
|
|
inside a double-quoted string is followed by
|
|
.Ql \e ,
|
|
.Ql $ ,
|
|
.Ql `
|
|
or
|
|
.Ql \&" ,
|
|
it is replaced by the second character; if it is followed by a newline, both
|
|
the
|
|
.Ql \e
|
|
and the newline are stripped; otherwise, both the
|
|
.Ql \e
|
|
and the character following are unchanged.
|
|
.Pp
|
|
.Sy Note:
|
|
See
|
|
.Sx POSIX mode
|
|
below for a special rule regarding sequences of the form
|
|
.Ic \&"...`...\e\&"...`..\&" .
|
|
.Ss Aliases
|
|
There are two types of aliases: normal command aliases and tracked aliases.
|
|
Command aliases are normally used as a short hand for a long or often used
|
|
command.
|
|
The shell expands command aliases (i.e., substitutes the alias name
|
|
for its value) when it reads the first word of a command.
|
|
An expanded alias is re-processed to check for more aliases.
|
|
If a command alias ends in a
|
|
space or tab, the following word is also checked for alias expansion.
|
|
The alias expansion process stops when a word that is not an alias is found,
|
|
when a quoted word is found or when an alias word that is currently being
|
|
expanded is found.
|
|
.Pp
|
|
The following command aliases are defined automatically by the shell:
|
|
.Pp
|
|
.Bl -item -offset indent -compact
|
|
.It
|
|
.Ic autoload='typeset -fu'
|
|
.It
|
|
.Ic functions='typeset -f'
|
|
.It
|
|
.Ic hash='alias -t'
|
|
.It
|
|
.Ic history='fc -l'
|
|
.It
|
|
.Ic integer='typeset -i'
|
|
.It
|
|
.Ic local='typeset'
|
|
.It
|
|
.Ic login='exec login'
|
|
.It
|
|
.Ic nohup='nohup '
|
|
.It
|
|
.Ic r='fc -e -'
|
|
.It
|
|
.Ic stop='kill -STOP'
|
|
.It
|
|
.Ic suspend='kill -STOP $$'
|
|
.It
|
|
.Ic type='whence -v'
|
|
.El
|
|
.Pp
|
|
Tracked aliases allow the shell to remember where it found a particular
|
|
command.
|
|
The first time the shell does a path search for a command that is
|
|
marked as a tracked alias, it saves the full path of the command.
|
|
The next
|
|
time the command is executed, the shell checks the saved path to see that it
|
|
is still valid and, if so, avoids repeating the path search.
|
|
Tracked aliases can be listed and created using
|
|
.Ic alias -t .
|
|
Note that changing the
|
|
.Ev PATH
|
|
parameter clears the saved paths for all tracked aliases.
|
|
If the
|
|
.Ic trackall
|
|
option is set (i.e.,
|
|
.Ic set Fl o Ic trackall
|
|
or
|
|
.Ic set Fl h ) ,
|
|
the shell tracks all commands.
|
|
This option is set automatically for non-interactive shells.
|
|
For interactive shells, only the following commands are
|
|
automatically tracked:
|
|
.Ic cat , cc , chmod , cp ,
|
|
.Ic date , ed , emacs , grep ,
|
|
.Ic ls , mail , make , mv ,
|
|
.Ic pr , rm , sed , sh ,
|
|
.Ic vi
|
|
and
|
|
.Ic who .
|
|
.Ss Substitution
|
|
The first step the shell takes in executing a simple-command is to perform
|
|
substitutions on the words of the command.
|
|
There are three kinds of
|
|
substitution: parameter, command and arithmetic.
|
|
Parameter substitutions,
|
|
which are described in detail in the next section, take the form
|
|
.Ic $ Ns Ar name
|
|
or
|
|
.Ic ${ Ns Ar ... Ns Ic \&} ;
|
|
command substitutions take the form
|
|
.Ic $( Ns Ar command Ns Ic \&)
|
|
or
|
|
.Ic ` Ns Ar command Ns Ic ` ;
|
|
and arithmetic substitutions take the form
|
|
.Ic $(( Ns Ar expression Ns Ic )) .
|
|
.Pp
|
|
If a substitution appears outside of double quotes, the results of the
|
|
substitution are generally subject to word or field splitting according to
|
|
the current value of the
|
|
.Ev IFS
|
|
parameter.
|
|
The
|
|
.Ev IFS
|
|
parameter specifies a list of characters which are used to break a string up
|
|
into several words; any characters from the set space, tab and newline that
|
|
appear in the
|
|
.Ev IFS
|
|
characters are called
|
|
.Dq IFS whitespace .
|
|
Sequences of one or more
|
|
.Ev IFS
|
|
whitespace characters, in combination with zero or one
|
|
.Pf non- Ev IFS
|
|
whitespace
|
|
characters, delimit a field.
|
|
As a special case, leading and trailing
|
|
.Ev IFS
|
|
whitespace and trailing
|
|
.Ev IFS
|
|
non-whitespace are stripped (i.e., no leading or trailing
|
|
empty field is created by it); leading
|
|
.Pf non- Ev IFS
|
|
whitespace does create an empty field.
|
|
.Pp
|
|
Example: If
|
|
.Ev IFS
|
|
is set to
|
|
.Dq <space>: ,
|
|
the sequence of characters
|
|
.Dq <space>A<space>:<space><space>B::D
|
|
contains four fields:
|
|
.Sq A ,
|
|
.Sq B ,
|
|
.Sq
|
|
(an empty field) and
|
|
.Sq D .
|
|
Note that if the
|
|
.Ev IFS
|
|
parameter is set to the null
|
|
string, no field splitting is done; if the parameter is unset, the default
|
|
value of space, tab and newline is used.
|
|
.Pp
|
|
The results of substitution are, unless otherwise specified, also subject to
|
|
brace expansion and file name expansion (see the relevant sections below).
|
|
.Pp
|
|
A command substitution is replaced by the output generated by the specified
|
|
command, which is run in a subshell.
|
|
For
|
|
.Ic $( Ns Ar command Ns Ic \&)
|
|
substitutions, normal quoting rules are used when
|
|
.Ar command
|
|
is parsed; however, for the
|
|
.Ic ` Ns Ar command Ns Ic `
|
|
form, a
|
|
.Ql \e
|
|
followed by any of
|
|
.Ql $ ,
|
|
.Ql `
|
|
or
|
|
.Ql \e
|
|
is stripped (a
|
|
.Ql \e
|
|
followed by any other character is unchanged).
|
|
As a special case in command substitutions, a command of the form
|
|
.Ic \&< Ar file
|
|
is interpreted to mean substitute the contents of
|
|
.Ar file
|
|
(note that
|
|
.Ic $(< foo)
|
|
has the same effect as
|
|
.Ic $(cat foo) ,
|
|
but it is carried out more efficiently because no process is started).
|
|
.Pp
|
|
.Sy Note:
|
|
.Ic $( Ns Ar command Ns Ic \&)
|
|
expressions are currently parsed by finding the matching parenthesis,
|
|
regardless of quoting.
|
|
This should be fixed soon.
|
|
.Pp
|
|
Arithmetic substitutions are replaced by the value of the specified expression.
|
|
For example, the command
|
|
.Ic print $((2+3*4))
|
|
displays 14.
|
|
See
|
|
.Sx Arithmetic expressions
|
|
for a description of an expression.
|
|
.Ss Parameters
|
|
Parameters are shell variables; they can be assigned values and their values
|
|
can be accessed using a parameter substitution.
|
|
A parameter name is either one
|
|
of the special single punctuation or digit character parameters described
|
|
below or a letter followed by zero or more letters or digits
|
|
.Po
|
|
.Ql _
|
|
counts as a letter
|
|
.Pc .
|
|
The latter form can be treated as arrays by appending an array index of the
|
|
form
|
|
.Op Ar expr
|
|
where
|
|
.Ar expr
|
|
is an arithmetic expression.
|
|
Array indices are currently limited to the range 0 through 2147483647 (for
|
|
.Nm mksh )
|
|
or 0 to 1023 (for other korn shells), inclusive.
|
|
Parameter substitutions take the form
|
|
.Ic $ Ns Ar name ,
|
|
.Ic ${ Ns Ar name Ns Ic \&}
|
|
or
|
|
.Sm off
|
|
.Xo
|
|
.Ic ${ Ar name Oo Ar expr Oc
|
|
.Ic \&} ,
|
|
.Xc
|
|
.Sm on
|
|
where
|
|
.Ar name
|
|
is a parameter name.
|
|
If substitution is performed on a parameter
|
|
(or an array parameter element)
|
|
that is not set, a null string is substituted unless the
|
|
.Ic nounset
|
|
option
|
|
.Po
|
|
.Ic set Fl o Ic nounset
|
|
or
|
|
.Ic set Fl u
|
|
.Pc
|
|
is set, in which case an error occurs.
|
|
.Pp
|
|
Parameters can be assigned values in a number of ways.
|
|
First, the shell implicitly sets some parameters like
|
|
.Ic # , PWD ,
|
|
etc.; this is the only way the special single character parameters are set.
|
|
Second, parameters are imported from the shell's environment at startup.
|
|
Third, parameters can be assigned values on the command line, for example,
|
|
.Ic FOO=bar
|
|
sets the parameter
|
|
.Ev FOO
|
|
to
|
|
.Dq bar ;
|
|
multiple parameter assignments can be given on a single command line and they
|
|
can be followed by a simple-command, in which case the assignments are in
|
|
effect only for the duration of the command (such assignments are also
|
|
exported, see below for implications of this).
|
|
Note that both the parameter name and the
|
|
.Ql =
|
|
must be unquoted for the shell to recognize a parameter assignment.
|
|
The fourth way of setting a parameter is with the
|
|
.Ic export ,
|
|
.Ic readonly
|
|
and
|
|
.Ic typeset
|
|
commands; see their descriptions in the
|
|
.Sx Command execution
|
|
section.
|
|
Fifth,
|
|
.Ic for
|
|
and
|
|
.Ic select
|
|
loops set parameters as well as the
|
|
.Ic getopts ,
|
|
.Ic read
|
|
and
|
|
.Ic set Fl A
|
|
commands.
|
|
Lastly, parameters can be assigned values using assignment operators
|
|
inside arithmetic expressions (see
|
|
.Sx Arithmetic expressions
|
|
below) or using the
|
|
.Xo Ic ${ Ns Ar name Ns =
|
|
.Ns Ar value Ns Ic \&}
|
|
.Xc
|
|
form of the parameter substitution (see below).
|
|
.Pp
|
|
Parameters with the export attribute (set using the
|
|
.Ic export
|
|
or
|
|
.Ic typeset Fl x
|
|
commands or by parameter assignments followed by simple commands) are put in
|
|
the environment (see
|
|
.Xr environ 7 )
|
|
of commands run by the shell as
|
|
.Ar name Ns = Ns Ar value
|
|
pairs.
|
|
The order in which parameters appear in the environment of a command is
|
|
unspecified.
|
|
When the shell starts up, it extracts parameters and their values
|
|
from its environment and automatically sets the export attribute for those
|
|
parameters.
|
|
.Pp
|
|
Modifiers can be applied to the
|
|
.Ic ${ Ns Ar name Ns Ic \&}
|
|
form of parameter substitution:
|
|
.Bl -tag -width Ds
|
|
.It Xo Ic ${ Ns Ar name Ns
|
|
.Ic \&:\&- Ns Ar word Ns Ic \&}
|
|
.Xc
|
|
If
|
|
.Ar name
|
|
is set and not
|
|
.Dv NULL ,
|
|
it is substituted; otherwise,
|
|
.Ar word
|
|
is substituted.
|
|
.It Xo Ic ${ Ns Ar name Ns
|
|
.Ic \&:\&+ Ns Ar word Ns Ic \&}
|
|
.Xc
|
|
If
|
|
.Ar name
|
|
is set and not
|
|
.Dv NULL ,
|
|
.Ar word
|
|
is substituted; otherwise, nothing is substituted.
|
|
.It Xo Ic ${ Ns Ar name Ns
|
|
.Ic \&:\&= Ns Ar word Ns Ic \&}
|
|
.Xc
|
|
If
|
|
.Ar name
|
|
is set and not
|
|
.Dv NULL ,
|
|
it is substituted; otherwise, it is assigned
|
|
.Ar word
|
|
and the resulting value of
|
|
.Ar name
|
|
is substituted.
|
|
.It Xo Ic ${ Ns Ar name Ns
|
|
.Ic \&:\&? Ns Ar word Ns Ic \&}
|
|
.Xc
|
|
If
|
|
.Ar name
|
|
is set and not
|
|
.Dv NULL ,
|
|
it is substituted; otherwise,
|
|
.Ar word
|
|
is printed on standard error (preceded by
|
|
.Ar name Ns \&: )
|
|
and an error occurs (normally causing termination of a shell script, function
|
|
or .-script).
|
|
If word is omitted the string
|
|
.Dq parameter null or not set
|
|
is used instead.
|
|
.El
|
|
.Pp
|
|
In the above modifiers, the
|
|
.Ql \&:
|
|
can be omitted, in which case the conditions only depend on
|
|
.Ar name
|
|
being set (as opposed to set and not
|
|
.Dv NULL ) .
|
|
If
|
|
.Ar word
|
|
is needed, parameter, command, arithmetic and tilde substitution are performed
|
|
on it; if
|
|
.Ar word
|
|
is not needed, it is not evaluated.
|
|
.Pp
|
|
The following forms of parameter substitution can also be used:
|
|
.Bl -tag -width Ds
|
|
.It Ic ${# Ns Ar name Ns Ic \&}
|
|
The number of positional parameters if
|
|
.Ar name
|
|
is
|
|
.Ql * ,
|
|
.Ql @ ,
|
|
not specified, or the length of the string value of parameter
|
|
.Ar name .
|
|
.It Xo Ic ${# Ns Ar name Ns
|
|
.Ic [*\&]} , ${# Ns Ar name Ns Ic [@\&]}
|
|
.Xc
|
|
The number of elements in the array
|
|
.Ar name .
|
|
.Sm off
|
|
.It Xo
|
|
.Ic ${ Ar name Ic # Ar pattern
|
|
.Sm on
|
|
.Ic } ,
|
|
.Sm off
|
|
.Ic ${ Ar name Ic ## Ar pattern Ic \&}
|
|
.Xc
|
|
.Sm on
|
|
If
|
|
.Ar pattern
|
|
matches the beginning of the value of parameter
|
|
.Ar name ,
|
|
the matched text is deleted from the result of substitution.
|
|
A single
|
|
.Ql #
|
|
results in the shortest match, two of them result in the longest match.
|
|
.Sm off
|
|
.It Xo
|
|
.Ic ${ Ar name Ic % Ar pattern
|
|
.Sm on
|
|
.Ic } ,
|
|
.Sm off
|
|
.Ic ${ Ar name Ic %% Ar pattern Ic }
|
|
.Xc
|
|
.Sm on
|
|
Like
|
|
.Ic ${..#..}
|
|
substitution, but it deletes from the end of the value.
|
|
.El
|
|
.Pp
|
|
The following special parameters are implicitly set by the shell and cannot be
|
|
set directly using assignments:
|
|
.Bl -tag -width "1 ... 9"
|
|
.It Ev \&!
|
|
Process ID of the last background process started.
|
|
If no background processes have been started, the parameter is not set.
|
|
.It Ev \&#
|
|
The number of positional parameters (i.e.,
|
|
.Ic $1 , $2 ,
|
|
etc.).
|
|
.It Ev \&$
|
|
The process ID of the shell, or the
|
|
.Tn PID
|
|
of the original shell if it is a subshell.
|
|
Do
|
|
.Em NOT
|
|
use this mechanism for generating temporary file names; see
|
|
.Xr mktemp 1
|
|
instead.
|
|
.It Ev \&-
|
|
The concatenation of the current single letter options (see the
|
|
.Ic set
|
|
command below for a list of options).
|
|
.It Ev \&?
|
|
The exit status of the last non-asynchronous command executed.
|
|
If the last command was killed by a signal,
|
|
.Va \&$?\&
|
|
is set to 128 plus the signal number.
|
|
.It Ev 0
|
|
The name the shell was invoked with (i.e.,
|
|
.Li argv[0] )
|
|
or the
|
|
.Ar command-name
|
|
if it was invoked with the
|
|
.Fl c
|
|
option and the
|
|
.Ar command-name
|
|
was supplied, or the
|
|
.Ar file
|
|
argument, if it was supplied.
|
|
If the
|
|
.Ic posix
|
|
option is not set,
|
|
.Ic \&$0
|
|
is the name of the current function or script.
|
|
.It Ev 1 ... Ev 9
|
|
The first nine positional parameters that were supplied to the shell, function
|
|
or .-script.
|
|
Further positional parameters may be accessed using
|
|
.Ic ${ Ns Ar number Ns Ic \&} .
|
|
.It Ev \&*
|
|
All positional parameters (except parameter 0); i.e.,
|
|
.Ic $1 , $2 , $3 ,
|
|
\&...
|
|
If used
|
|
outside of double quotes, parameters are separate words (which are subjected
|
|
to word splitting); if used within double quotes, parameters are separated
|
|
by the first character of the
|
|
.Ev IFS
|
|
parameter (or the empty string if
|
|
.Ev IFS
|
|
is
|
|
.Dv NULL ) .
|
|
.It Ev \&@
|
|
Same as
|
|
.Ic \&$\&* ,
|
|
unless it is used inside double quotes, in which case a separate word is
|
|
generated for each positional parameter.
|
|
If there are no positional parameters, no word is generated.
|
|
.Ic \&$\&@
|
|
can be used to access arguments, verbatim, without losing
|
|
.Dv NULL
|
|
arguments or splitting arguments with spaces.
|
|
.El
|
|
.Pp
|
|
The following parameters are set and/or used by the shell:
|
|
.Bl -tag -width "EXECSHELL"
|
|
.It Ev \&_ No (underscore)
|
|
When an external command is executed by the shell, this parameter is set in the
|
|
environment of the new process to the path of the executed command.
|
|
In interactive use, this parameter is also set in the parent shell to the last
|
|
word of the previous command.
|
|
.It Ev CDPATH
|
|
Search path for the
|
|
.Ic cd
|
|
built-in command.
|
|
Works the same way as
|
|
.Ev PATH
|
|
for those directories not beginning with
|
|
.Ql /
|
|
in
|
|
.Ic cd
|
|
commands.
|
|
Note that if
|
|
.Ev CDPATH
|
|
is set and does not contain
|
|
.Dq \&.
|
|
or contains an empty path, the current directory is not searched.
|
|
Also, the
|
|
.Ic cd
|
|
built-in command will display the resulting directory when a match is found
|
|
in any search path other than the empty path.
|
|
.It Ev COLUMNS
|
|
Set to the number of columns on the terminal or window.
|
|
Currently set to the
|
|
.Dq cols
|
|
value as reported by
|
|
.Xr stty 1
|
|
if that value is non-zero.
|
|
This parameter is used by the
|
|
interactive line editing modes and by the
|
|
.Ic select ,
|
|
.Ic set Fl o
|
|
and
|
|
.Ic kill Fl l
|
|
commands to format information columns.
|
|
.It Ev EDITOR
|
|
If the
|
|
.Ev VISUAL
|
|
parameter is not set, this parameter controls the command-line editing mode for
|
|
interactive shells.
|
|
See
|
|
.Ev VISUAL
|
|
parameter below for how this works.
|
|
.It Ev ENV
|
|
If this parameter is found to be set after any profile files are executed, the
|
|
expanded value is used as a shell startup file.
|
|
It typically contains function and alias definitions.
|
|
.It Ev ERRNO
|
|
Integer value of the shell's
|
|
.Va errno
|
|
variable.
|
|
It indicates the reason the last system call failed.
|
|
Not yet implemented.
|
|
.It Ev EXECSHELL
|
|
If set, this parameter is assumed to contain the shell that is to be used to
|
|
execute commands that
|
|
.Xr execve 2
|
|
fails to execute and which do not start with a
|
|
.Dq \&#\&! Ns Ar shell
|
|
sequence.
|
|
.It Ev FCEDIT
|
|
The editor used by the
|
|
.Ic fc
|
|
command (see below).
|
|
.It Ev FPATH
|
|
Like
|
|
.Ev PATH ,
|
|
but used when an undefined function is executed to locate the file defining the
|
|
function.
|
|
It is also searched when a command can't be found using
|
|
.Ev PATH .
|
|
See
|
|
.Sx Functions
|
|
below for more information.
|
|
.It Ev HISTFILE
|
|
The name of the file used to store command history.
|
|
When assigned to, history is loaded from the specified file.
|
|
Also, several invocations of the shell
|
|
running on the same machine will share history if their
|
|
.Ev HISTFILE
|
|
parameters all point to the same file.
|
|
.Pp
|
|
.Sy Note:
|
|
If
|
|
.Ev HISTFILE
|
|
isn't set, no history file is used.
|
|
This is different from the original Korn shell.
|
|
.It Ev HISTSIZE
|
|
The number of commands normally stored for history.
|
|
The default is 511.
|
|
.It Ev HOME
|
|
The default directory for the
|
|
.Ic cd
|
|
command and the value substituted for an unqualified
|
|
.Ic ~
|
|
(see
|
|
.Sx Tilde expansion
|
|
below).
|
|
.It Ev IFS
|
|
Internal field separator, used during substitution and by the
|
|
.Ic read
|
|
command, to split values into distinct arguments; normally set to space, tab
|
|
and newline.
|
|
See
|
|
.Sx Substitution
|
|
above for details.
|
|
.Pp
|
|
.Sy Note:
|
|
This parameter is not imported from the environment when the shell is
|
|
started.
|
|
.It Ev KSH_VERSION
|
|
The version of
|
|
.Nm
|
|
(read-only).
|
|
See also the version commands in
|
|
.Sx Emacs editing mode
|
|
and
|
|
.Sx Vi editing mode
|
|
sections, below.
|
|
.It Ev LINENO
|
|
The line number of the function or shell script that is currently being
|
|
executed.
|
|
.It Ev LINES
|
|
Set to the number of lines on the terminal or window.
|
|
Not yet implemented.
|
|
.It Ev OLDPWD
|
|
The previous working directory.
|
|
Unset if
|
|
.Ic cd
|
|
has not successfully changed directories since the shell started or the
|
|
shell doesn't know where it is.
|
|
.It Ev OPTARG
|
|
When using
|
|
.Ic getopts ,
|
|
it contains the argument for a parsed option, if it requires one.
|
|
.It Ev OPTIND
|
|
The index of the last argument processed when using
|
|
.Ic getopts .
|
|
Assigning 1 to this parameter causes
|
|
.Ic getopts
|
|
to process arguments from the beginning the next time it is invoked.
|
|
.It Ev PATH
|
|
A colon separated list of directories that are searched when looking for
|
|
commands and .'d files.
|
|
An empty string resulting from a leading or trailing
|
|
colon, or two adjacent colons, is treated as a
|
|
.Dq \&. ,
|
|
the current directory.
|
|
This is dangerous.
|
|
.It Ev POSIXLY_CORRECT
|
|
If set, this parameter causes the
|
|
.Ic posix
|
|
option to be enabled.
|
|
See
|
|
.Sx POSIX mode
|
|
below.
|
|
.It Ev PPID
|
|
The process ID of the shell's parent (read-only).
|
|
.It Ev PS1
|
|
The primary prompt for interactive shells.
|
|
Parameter, command and arithmetic substitutions are performed, and
|
|
.Ql \&!
|
|
is replaced with the current command number (see the
|
|
.Ic fc
|
|
command below).
|
|
A literal
|
|
.Ql \&!
|
|
can be put in the prompt by placing
|
|
.Ql !!
|
|
in
|
|
.Ev PS1 .
|
|
Note that since the command-line editors try to figure out how long the prompt
|
|
is (so they know how far it is to the edge of the screen), escape codes in
|
|
the prompt tend to mess things up.
|
|
You can tell the shell not to count certain
|
|
sequences (such as escape codes) by prefixing your prompt with a non-printing
|
|
character (such as control-A) followed by a carriage return and then delimiting
|
|
the escape codes with this non-printing character.
|
|
If you don't have any non-printing characters, you're out of luck.
|
|
By the way, don't blame me for
|
|
this hack; it's in the original
|
|
.Xr ksh88 1 .
|
|
Default is
|
|
.Dq \&$\ \&
|
|
for non-root users,
|
|
.Dq \&#\ \&
|
|
for root.
|
|
.Pp
|
|
Since Backslashes and other special characters may be
|
|
interpreted by the shell, to set
|
|
.Ev PS1
|
|
either escape the backslash itself or use double quotes.
|
|
The latter is more practical.
|
|
This is a more complex example which embeds the current working
|
|
directory, in reverse video, into the prompt string, avoiding to
|
|
directly enter special characters (for example with
|
|
.Ic ^^
|
|
in the emacs editing mode):
|
|
.Bd -literal -offset indent
|
|
x=$(print \e\e001)
|
|
PS1="$x$(print \e\er)$x$(tput so)$x\e$PWD$x$(tput se)$x> "
|
|
.Ed
|
|
.It Ev PS2
|
|
Secondary prompt string, by default
|
|
.Dq \&>\ \& ,
|
|
used when more input is needed to complete a command.
|
|
.It Ev PS3
|
|
Prompt used by the
|
|
.Ic select
|
|
statement when reading a menu selection.
|
|
Default is
|
|
.Dq \&#\&?\ \& .
|
|
.It Ev PS4
|
|
Used to prefix commands that are printed during execution tracing (see the
|
|
.Ic set Fl x
|
|
command below).
|
|
Parameter, command and arithmetic substitutions are performed
|
|
before it is printed.
|
|
Default is
|
|
.Dq \&+\ \& .
|
|
.It Ev PWD
|
|
The current working directory.
|
|
May be unset or
|
|
.Dv NULL
|
|
if the shell doesn't know where it is.
|
|
.It Ev RANDOM
|
|
A pseudo-random number generator.
|
|
Every time
|
|
.Ev RANDOM
|
|
is referenced, it is assigned a random number in the range
|
|
0\-32767.
|
|
Until the variable is written to, the
|
|
.Xr arc4random 3
|
|
function is being used, after a write or if the function is not available,
|
|
.Xr random 3
|
|
or, if that does not exist,
|
|
.Xr rand 3 ,
|
|
is being used.
|
|
On startup and fork, the value is seeded and the initial state of
|
|
not being written to initialised.
|
|
If a feedback function is provided, changed values are propagated
|
|
back to the arcfour random number generator.
|
|
.It Ev REPLY
|
|
Default parameter for the
|
|
.Ic read
|
|
command if no names are given.
|
|
Also used in
|
|
.Ic select
|
|
loops to store the value that is read from standard input.
|
|
.It Ev SECONDS
|
|
The number of seconds since the shell started or, if the parameter has been
|
|
assigned an integer value, the number of seconds since the assignment plus the
|
|
value that was assigned.
|
|
.It Ev TMOUT
|
|
If set to a positive integer in an interactive shell, it specifies the maximum
|
|
number of seconds the shell will wait for input after printing the primary
|
|
prompt
|
|
.Pq Ev PS1 .
|
|
If the time is exceeded, the shell exits.
|
|
.It Ev TMPDIR
|
|
The directory shell temporary files are created in.
|
|
If this parameter is not
|
|
set or does not contain the absolute path of a writable directory, temporary
|
|
files are created in
|
|
.Pa /tmp .
|
|
.It Ev VISUAL
|
|
If set, this parameter controls the command-line editing mode for interactive
|
|
shells.
|
|
If the last component of the path specified in this parameter contains
|
|
the string
|
|
.Dq vi ,
|
|
.Dq emacs
|
|
or
|
|
.Dq gmacs ,
|
|
the
|
|
.Xr vi ,
|
|
.Xr emacs
|
|
or
|
|
.Xr gmacs
|
|
(Gosling emacs) editing mode is enabled, respectively.
|
|
.El
|
|
.Ss Tilde expansion
|
|
Tilde expansion, which is done in parallel with parameter substitution, is done
|
|
on words starting with an unquoted
|
|
.Ql ~ .
|
|
The characters following the tilde, up to the first
|
|
.Ql / ,
|
|
if any, are assumed to be a login name.
|
|
If the login name is empty,
|
|
.Ql +
|
|
or
|
|
.Ql - ,
|
|
the value of the
|
|
.Ev HOME ,
|
|
.Ev PWD
|
|
or
|
|
.Ev OLDPWD
|
|
parameter is substituted, respectively.
|
|
Otherwise, the password file is
|
|
searched for the login name, and the tilde expression is substituted with the
|
|
user's home directory.
|
|
If the login name is not found in the password file or
|
|
if any quoting or parameter substitution occurs in the login name, no
|
|
substitution is performed.
|
|
.Pp
|
|
In parameter assignments (those preceding a simple-command or those occurring
|
|
in the arguments of
|
|
.Ic alias ,
|
|
.Ic export ,
|
|
.Ic readonly
|
|
and
|
|
.Ic typeset ) ,
|
|
tilde expansion is done after any unquoted colon
|
|
.Pq Sq \&: ,
|
|
and login names are also delimited by colons.
|
|
.Pp
|
|
The home directory of previously expanded login names are cached and re-used.
|
|
The
|
|
.Ic alias -d
|
|
command may be used to list, change and add to this cache (e.g.,
|
|
.Ic alias -d fac=/usr/local/facilities; cd ~fac/bin ) .
|
|
.Ss Brace expansion (alteration)
|
|
Brace expressions, which take the form
|
|
.Bd -unfilled -offset indent
|
|
.Sm off
|
|
.Xo Ar prefix Ic { Ar str No 1,...,
|
|
.Ar str No N Ic } Ar suffix
|
|
.Xc
|
|
.Sm on
|
|
.Ed
|
|
.Pp
|
|
are expanded to N words, each of which is the concatenation of
|
|
.Ar prefix ,
|
|
.Ar str Ns i
|
|
and
|
|
.Ar suffix
|
|
(e.g.,
|
|
.Dq a{c,b{X,Y},d}e
|
|
expands to four words:
|
|
.Dq ace ,
|
|
.Dq abXe ,
|
|
.Dq abYe
|
|
and
|
|
.Dq ade ) .
|
|
As noted in the example, brace expressions can be nested and the resulting
|
|
words are not sorted.
|
|
Brace expressions must contain an unquoted comma
|
|
.Pq Sq \&,
|
|
for expansion to occur (i.e.,
|
|
.Ic {}
|
|
and
|
|
.Ic {foo}
|
|
are not expanded).
|
|
Brace expansion is carried out after parameter substitution
|
|
and before file name generation.
|
|
.Ss File name patterns
|
|
A file name pattern is a word containing one or more unquoted
|
|
.Ql \&?
|
|
or
|
|
.Ql *
|
|
characters or
|
|
.Dq [..]
|
|
sequences.
|
|
Once brace expansion has been performed, the shell replaces file
|
|
name patterns with the sorted names of all the files that match the pattern
|
|
(if no files match, the word is left unchanged).
|
|
The pattern elements have the following meaning:
|
|
.Bl -tag -width Ds
|
|
.It Ic \&?
|
|
Matches any single character.
|
|
.It Ic \&*
|
|
Matches any sequence of characters.
|
|
.It Ic \&[ Ns .. Ns Ic \&]
|
|
Matches any of the characters inside the brackets.
|
|
Ranges of characters can be
|
|
specified by separating two characters by a
|
|
.Ql -
|
|
(e.g.,
|
|
.Dq [a0-9]
|
|
matches the letter
|
|
.Dq a
|
|
or any digit).
|
|
In order to represent itself, a
|
|
.Ql -
|
|
must either be quoted or the first or last character in the character list.
|
|
Similarly, a
|
|
.Ql \&]
|
|
must be quoted or the first character in the list if it is to represent itself
|
|
instead of the end of the list.
|
|
Also, a
|
|
.Ql \&!
|
|
appearing at the start of the list has special meaning (see below), so to
|
|
represent itself it must be quoted or appear later in the list.
|
|
.It Ic \&[\&! Ns .. Ns Ic \&]
|
|
Like
|
|
.Ic \&[ Ns .. Ns Ic \&] ,
|
|
except it matches any character not inside the brackets.
|
|
.Sm off
|
|
.It Xo Ic \&*( Ar pattern Ic \&| No \ ...\ \&
|
|
.Ic \&| Ar pattern Ic \&)
|
|
.Xc
|
|
.Sm on
|
|
Matches any string of characters that matches zero or more occurrences of the
|
|
specified patterns.
|
|
Example: The pattern
|
|
.Ic \&*(foo\&|bar)
|
|
matches the strings
|
|
.Dq ,
|
|
.Dq foo ,
|
|
.Dq bar ,
|
|
.Dq foobarfoo ,
|
|
etc.
|
|
.Sm off
|
|
.It Xo Ic \&+( Ar pattern Ic \&| No \ ...\ \&
|
|
.Ic \&| Ar pattern Ic \&)
|
|
.Xc
|
|
.Sm on
|
|
Matches any string of characters that matches one or more occurrences of the
|
|
specified patterns.
|
|
Example: The pattern
|
|
.Ic \&+(foo\&|bar)
|
|
matches the strings
|
|
.Dq foo ,
|
|
.Dq bar ,
|
|
.Dq foobar ,
|
|
etc.
|
|
.Sm off
|
|
.It Xo Ic \&?( Ar pattern Ic \&| No \ ...\ \&
|
|
.Ic \&| Ar pattern Ic \&)
|
|
.Xc
|
|
.Sm on
|
|
Matches the empty string or a string that matches one of the specified
|
|
patterns.
|
|
Example: The pattern
|
|
.Ic \&?(foo\&|bar)
|
|
only matches the strings
|
|
.Dq ,
|
|
.Dq foo
|
|
and
|
|
.Dq bar .
|
|
.Sm off
|
|
.It Xo Ic \&@( Ar pattern Ic \&| No \ ...\ \&
|
|
.Ic \&| Ar pattern Ic \&)
|
|
.Xc
|
|
.Sm on
|
|
Matches a string that matches one of the specified patterns.
|
|
Example: The pattern
|
|
.Ic \&@(foo\&|bar)
|
|
only matches the strings
|
|
.Dq foo
|
|
and
|
|
.Dq bar .
|
|
.Sm off
|
|
.It Xo Ic \&!( Ar pattern Ic \&| No \ ...\ \&
|
|
.Ic \&| Ar pattern Ic \&)
|
|
.Xc
|
|
.Sm on
|
|
Matches any string that does not match one of the specified patterns.
|
|
Examples: The pattern
|
|
.Ic \&!(foo\&|bar)
|
|
matches all strings except
|
|
.Dq foo
|
|
and
|
|
.Dq bar ;
|
|
the pattern
|
|
.Ic \&!(\&*)
|
|
matches no strings; the pattern
|
|
.Ic \&!(\&?)\&*
|
|
matches all strings (think about it).
|
|
.El
|
|
.Pp
|
|
Note that
|
|
.Nm
|
|
currently never matches
|
|
.Dq \&.
|
|
and
|
|
.Dq \&.\&. ,
|
|
but the original
|
|
.Xr ksh ,
|
|
Bourne
|
|
.Xr sh
|
|
and GNU
|
|
.Xr bash
|
|
do.
|
|
.Pp
|
|
Note that none of the above pattern elements match either a period
|
|
.Pq Sq \&.
|
|
at the start of a file name or a slash
|
|
.Pq Sq / ,
|
|
even if they are explicitly used in a
|
|
.Ic \&[ Ns .. Ns Ic \&]
|
|
sequence; also, the names
|
|
.Dq \&.
|
|
and
|
|
.Dq \&.\&.
|
|
are never matched, even by the pattern
|
|
.Dq \&.\&* .
|
|
.Pp
|
|
If the
|
|
.Ic markdirs
|
|
option is set, any directories that result from file name generation are marked
|
|
with a trailing
|
|
.Ql / .
|
|
.Pp
|
|
The
|
|
.Tn POSIX
|
|
character classes (i.e.,
|
|
.Ic \&[\&: Ns Ar class-name Ns Ic \&:\&]
|
|
inside a
|
|
.Ic \&[ Ns .. Ns Ic \&]
|
|
expression) are not yet implemented.
|
|
.Ss Input/output redirection
|
|
When a command is executed, its standard input, standard output and standard
|
|
error (file descriptors 0, 1 and 2, respectively) are normally inherited from
|
|
the shell.
|
|
Three exceptions to this are commands in pipelines, for which
|
|
standard input and/or standard output are those set up by the pipeline,
|
|
asynchronous commands created when job control is disabled, for which standard
|
|
input is initially set to be from
|
|
.Pa /dev/null ,
|
|
and commands for which any of the following redirections have been specified:
|
|
.Bl -tag -width Ds
|
|
.It Ic \&> Ar file
|
|
Standard output is redirected to
|
|
.Ar file .
|
|
If
|
|
.Ar file
|
|
does not exist, it is created; if it does exist, is a regular file and the
|
|
.Ic noclobber
|
|
option is set, an error occurs; otherwise, the file is truncated.
|
|
Note that this means the command
|
|
.Ic cmd < foo > foo
|
|
will open
|
|
.Ar foo
|
|
for reading and then truncate it when it opens it for writing, before
|
|
.Ar cmd
|
|
gets a chance to actually read
|
|
.Ar foo .
|
|
.It Ic \&>\&| Ar file
|
|
Same as
|
|
.Ic \&> ,
|
|
except the file is truncated, even if the
|
|
.Ic noclobber
|
|
option is set.
|
|
.It Ic \&>\&> Ar file
|
|
Same as
|
|
.Ic \&> ,
|
|
except if
|
|
.Ar file
|
|
exists it is appended to instead of being truncated.
|
|
Also, the file is opened
|
|
in append mode, so writes always go to the end of the file (see
|
|
.Xr open 2 ) .
|
|
.It Ic \&< Ar file
|
|
Standard input is redirected from
|
|
.Ar file ,
|
|
which is opened for reading.
|
|
.It Ic \&<\&> Ar file
|
|
Same as
|
|
.Ic \&< ,
|
|
except the file is opened for reading and writing.
|
|
.It Ic \&<\&< Ar marker
|
|
After reading the command line containing this kind of redirection (called a
|
|
.Dq here document ) ,
|
|
the shell copies lines from the command source into a temporary file until a
|
|
line matching
|
|
.Ar marker
|
|
is read.
|
|
When the command is executed, standard input is redirected from the
|
|
temporary file.
|
|
If
|
|
.Ar marker
|
|
contains no quoted characters, the contents of the temporary file are processed
|
|
as if enclosed in double quotes each time the command is executed, so
|
|
parameter, command and arithmetic substitutions are performed, along with
|
|
backslash
|
|
.Pq Sq \e
|
|
escapes for
|
|
.Ql $ ,
|
|
.Ql ` ,
|
|
.Ql \e
|
|
and
|
|
.Ql \enewline .
|
|
If multiple here documents are used on the same command line, they are saved in
|
|
order.
|
|
.It Ic \&<\&<\&- Ar marker
|
|
Same as
|
|
.Ic \&<\&< ,
|
|
except leading tabs are stripped from lines in the here document.
|
|
.It Ic \&<\&& Ar fd
|
|
Standard input is duplicated from file descriptor
|
|
.Ar fd .
|
|
.Ar fd
|
|
can be a single digit, indicating the number of an existing file descriptor;
|
|
the letter
|
|
.Ql p ,
|
|
indicating the file descriptor associated with the output of the current
|
|
co-process; or the character
|
|
.Ql - ,
|
|
indicating standard input is to be closed.
|
|
.It Ic \&>\&& Ar fd
|
|
Same as
|
|
.Ic \&<\&& ,
|
|
except the operation is done on standard output.
|
|
.El
|
|
.Pp
|
|
In any of the above redirections, the file descriptor that is redirected (i.e.,
|
|
standard input or standard output) can be explicitly given by preceding the
|
|
redirection with a single digit.
|
|
Parameter, command and arithmetic
|
|
substitutions, tilde substitutions and, if the shell is interactive,
|
|
file name generation are all performed on the
|
|
.Ar file ,
|
|
.Ar marker
|
|
and
|
|
.Ar fd
|
|
arguments of redirections.
|
|
Note, however, that the results of any file name
|
|
generation are only used if a single file is matched; if multiple files match,
|
|
the word with the expanded file name generation characters is used.
|
|
Note
|
|
that in restricted shells, redirections which can create files cannot be used.
|
|
.Pp
|
|
For simple-commands, redirections may appear anywhere in the command; for
|
|
compound-commands
|
|
.Po
|
|
.Ic if
|
|
statements, etc.
|
|
.Pc ,
|
|
any redirections must appear at the end.
|
|
Redirections are processed after
|
|
pipelines are created and in the order they are given, so
|
|
.Pp
|
|
.Dl Ic cat /foo/bar 2\*(Gt&1 \*(Gt /dev/null \&| cat -n
|
|
.Pp
|
|
will print an error with a line number prepended to it.
|
|
.Ss Arithmetic expressions
|
|
Integer arithmetic expressions can be used with the
|
|
.Ic let
|
|
command, inside
|
|
.Ic $(( Ns .. Ns Ic ))
|
|
expressions, inside array references (e.g.,
|
|
.Sm off
|
|
.Ar name Ic \&[ Ar expr Ic \&] ) ,
|
|
.Sm on
|
|
as numeric arguments to the
|
|
.Ic test
|
|
command and as the value of an assignment to an integer parameter.
|
|
.Pp
|
|
Expressions may contain alpha-numeric parameter identifiers, array references
|
|
and integer constants and may be combined with the following C operators
|
|
(listed and grouped in increasing order of precedence):
|
|
.Pp
|
|
Unary operators:
|
|
.Bl -item -offset indent -compact
|
|
.It
|
|
.Ic \&+ \&- \&! \&~ \&+\&+ \&-\&-
|
|
.El
|
|
.Pp
|
|
Binary operators:
|
|
.Bl -item -offset indent -compact
|
|
.It
|
|
.Ic \&,
|
|
.It
|
|
.Ic = \&*= /= %= \&+= \&-= \&<\&<=
|
|
.Ic \&>\&>= \&&= ^= \&|=
|
|
.It
|
|
.Ic \&|\&|
|
|
.It
|
|
.Ic \&&\&&
|
|
.It
|
|
.Ic \&|
|
|
.It
|
|
.Ic ^
|
|
.It
|
|
.Ic \&&
|
|
.It
|
|
.Ic == \&!=
|
|
.It
|
|
.Ic \&< \&<= \&>= \&>
|
|
.It
|
|
.Ic \&<\&< \&>\&>
|
|
.It
|
|
.Ic \&+ \&-
|
|
.It
|
|
.Ic \&* / %
|
|
.El
|
|
.Pp
|
|
Ternary operators:
|
|
.Bl -item -offset indent -compact
|
|
.It
|
|
.Ic \&?\&:
|
|
(precedence is immediately higher than assignment)
|
|
.El
|
|
.Pp
|
|
Grouping operators:
|
|
.Bl -item -offset indent -compact
|
|
.It
|
|
.Ic \&( \&)
|
|
.El
|
|
.Pp
|
|
Integer constants may be specified with arbitrary bases using the notation
|
|
.Ar base Ns Ic \&# Ns Ar number ,
|
|
where
|
|
.Ar base
|
|
is a decimal integer specifying the base and
|
|
.Ar number
|
|
is a number in the specified base.
|
|
.Pp
|
|
The operators are evaluated as follows:
|
|
.Bl -tag -width Ds -offset indent
|
|
.It unary Ic \&+
|
|
Result is the argument (included for completeness).
|
|
.It unary Ic \&-
|
|
Negation.
|
|
.It Ic \&!
|
|
Logical
|
|
.Tn NOT ;
|
|
the result is 1 if argument is zero, 0 if not.
|
|
.It Ic \&~
|
|
Arithmetic (bit-wise)
|
|
.Tn NOT .
|
|
.It Ic \&+\&+
|
|
Increment; must be applied to a parameter (not a literal or other expression).
|
|
The parameter is incremented by 1.
|
|
When used as a prefix operator, the result
|
|
is the incremented value of the parameter; when used as a postfix operator, the
|
|
result is the original value of the parameter.
|
|
.It Ic \&-\&-
|
|
Similar to
|
|
.Ic \&+\&+ ,
|
|
except the parameter is decremented by 1.
|
|
.It Ic \&,
|
|
Separates two arithmetic expressions; the left-hand side is evaluated first,
|
|
then the right.
|
|
The result is the value of the expression on the right-hand side.
|
|
.It Ic =
|
|
Assignment; variable on the left is set to the value on the right.
|
|
.It Xo Ic \&*= /= \&+= \&-= \&<\&<=
|
|
.Ic \&>\&>= \&&= ^= \&|=
|
|
.Xc
|
|
Assignment operators.
|
|
.Ao Ar var Ac
|
|
.Ao Ar op Ac =
|
|
.Ao Ar expr Ac
|
|
is the same as
|
|
.Ao Ar var Ac =
|
|
.Ao Ar var Ac
|
|
.Ao Ar op Ac
|
|
.Ic \&(
|
|
.Ao Ar expr Ac
|
|
.Ic \&) .
|
|
.It Ic \&|\&|
|
|
Logical
|
|
.Tn OR ;
|
|
the result is 1 if either argument is non-zero, 0 if not.
|
|
The right argument is evaluated only if the left argument is zero.
|
|
.It Ic \&&\&&
|
|
Logical
|
|
.Tn AND ;
|
|
the result is 1 if both arguments are non-zero, 0 if not.
|
|
The right argument is evaluated only if the left argument is non-zero.
|
|
.It Ic \&|
|
|
Arithmetic (bit-wise)
|
|
.Tn OR .
|
|
.It Ic ^
|
|
Arithmetic (bit-wise)
|
|
.Tn XOR
|
|
(exclusive-OR).
|
|
.It Ic \&&
|
|
Arithmetic (bit-wise)
|
|
.Tn AND .
|
|
.It Ic ==
|
|
Equal; the result is 1 if both arguments are equal, 0 if not.
|
|
.It Ic \&!=
|
|
Not equal; the result is 0 if both arguments are equal, 1 if not.
|
|
.It Ic \&<
|
|
Less than; the result is 1 if the left argument is less than the right, 0 if
|
|
not.
|
|
.It Ic \&<= \&>= \&>
|
|
Less than or equal, greater than or equal, greater than.
|
|
See
|
|
.Ic \&< .
|
|
.It Ic \&<\&< \&>\&>
|
|
Shift left (right); the result is the left argument with its bits shifted left
|
|
(right) by the amount given in the right argument.
|
|
.It Ic \&+ \&- \&* /
|
|
Addition, subtraction, multiplication and division.
|
|
.It Ic %
|
|
Remainder; the result is the remainder of the division of the left argument by
|
|
the right.
|
|
The sign of the result is unspecified if either argument is negative.
|
|
.It Xo Ao Ar arg1 Ac Ic \ \&?
|
|
.Ao Ar arg2 Ac Ic \ \&: Ao Ar arg3 Ac
|
|
.Xc
|
|
.No If Ao Ar arg1 Ac
|
|
is non-zero, the result is
|
|
.Ao Ar arg2 Ac ,
|
|
otherwise
|
|
.Ao Ar arg3 Ac .
|
|
.El
|
|
.Ss Co-processes
|
|
A co-process, which is a pipeline created with the
|
|
.Ic \&|\&&
|
|
operator, is an asynchronous process that the shell can both write to (using
|
|
.Ic print -p )
|
|
and read from (using
|
|
.Ic read -p ) .
|
|
The input and output of the co-process can also be manipulated using
|
|
.Ic \&>\&&p
|
|
and
|
|
.Ic \&<\&&p
|
|
redirections, respectively.
|
|
Once a co-process has been started, another can't
|
|
be started until the co-process exits or the co-process's input has been
|
|
redirected using an
|
|
.Ic exec Ar n Ns Ic \&>\&&p
|
|
redirection.
|
|
If a co-process's input is redirected in this way, the next
|
|
co-process to be started will share the output with the first co-process,
|
|
unless the output of the initial co-process has been redirected using an
|
|
.Ic exec Ar n Ns Ic \&<\&&p
|
|
redirection.
|
|
.Pp
|
|
Some notes concerning co-processes:
|
|
.Bl -bullet
|
|
.It
|
|
The only way to close the co-process's input (so the co-process reads an
|
|
end-of-file) is to redirect the input to a numbered file descriptor and then
|
|
close that file descriptor (e.g.,
|
|
.Ic exec 3\&>\&&p\&; exec 3\&>\&&\&- ) .
|
|
.It
|
|
In order for co-processes to share a common output, the shell must keep the
|
|
write portion of the output pipe open.
|
|
This means that end-of-file will not be
|
|
detected until all co-processes sharing the co-process's output have exited
|
|
(when they all exit, the shell closes its copy of the pipe).
|
|
This can be
|
|
avoided by redirecting the output to a numbered file descriptor (as this also
|
|
causes the shell to close its copy).
|
|
Note that this behaviour is slightly
|
|
different from the original Korn shell which closes its copy of the write
|
|
portion of the co-process output when the most recently started co-process
|
|
(instead of when all sharing co-processes) exits.
|
|
.It
|
|
.Ic print -p
|
|
will ignore
|
|
.Dv SIGPIPE
|
|
signals during writes if the signal is not being trapped or ignored; the same
|
|
is true if the co-process input has been duplicated to another file descriptor
|
|
and
|
|
.Ic print -u Ns Ar n
|
|
is used.
|
|
.El
|
|
.Ss Functions
|
|
Functions are defined using either Korn shell
|
|
.Ic function Ar name
|
|
syntax or the Bourne/POSIX shell
|
|
.Fn name
|
|
syntax (see below for the difference between the two forms).
|
|
Functions are like
|
|
.Li .-scripts
|
|
in that they are executed in the current environment.
|
|
However, unlike
|
|
.Li .-scripts ,
|
|
shell arguments (i.e., positional parameters
|
|
.Ic $1 , $2 ,
|
|
etc.) are never visible inside them.
|
|
When the shell is determining the location of a command, functions
|
|
are searched after special built-in commands, before regular and
|
|
non-regular built-ins and before the
|
|
.Ev PATH
|
|
is searched.
|
|
.Pp
|
|
An existing function may be deleted using
|
|
.Ic unset Fl f Ar function-name .
|
|
A list of functions can be obtained using
|
|
.Ic typeset \&+f
|
|
and the function definitions can be listed using
|
|
.Ic typeset \&-f .
|
|
The
|
|
.Ic autoload
|
|
command (which is an alias for
|
|
.Ic typeset \&-fu )
|
|
may be used to create undefined functions; when an undefined function is
|
|
executed, the shell searches the path specified in the
|
|
.Ev FPATH
|
|
parameter for a file with the same name as the function, which, if found, is
|
|
read and executed.
|
|
If after executing the file the named function is found to
|
|
be defined, the function is executed; otherwise, the normal command search is
|
|
continued (i.e., the shell searches the regular built-in command table and
|
|
.Ev PATH ) .
|
|
Note that if a command is not found using
|
|
.Ev PATH ,
|
|
an attempt is made to autoload a function using
|
|
.Ev FPATH
|
|
(this is an undocumented feature of the original Korn shell).
|
|
.Pp
|
|
Functions can have two attributes,
|
|
.Dq trace
|
|
and
|
|
.Dq export ,
|
|
which can be set with
|
|
.Ic typeset \&-ft
|
|
and
|
|
.Ic typeset \&-fx ,
|
|
respectively.
|
|
When a traced function is executed, the shell's
|
|
.Ic xtrace
|
|
option is turned on for the function's duration; otherwise, the
|
|
.Ic xtrace
|
|
option is turned off.
|
|
The
|
|
.Dq export
|
|
attribute of functions is currently not used.
|
|
In the original Korn shell,
|
|
exported functions are visible to shell scripts that are executed.
|
|
.Pp
|
|
Since functions are executed in the current shell environment, parameter
|
|
assignments made inside functions are visible after the function completes.
|
|
If this is not the desired effect, the
|
|
.Ic typeset
|
|
command can be used inside a function to create a local parameter.
|
|
Note that special parameters (e.g.
|
|
.Ic \&$$ , $\&! )
|
|
can't be scoped in this way.
|
|
.Pp
|
|
The exit status of a function is that of the last command executed in the
|
|
function.
|
|
A function can be made to finish immediately using the
|
|
.Ic return
|
|
command; this may also be used to explicitly specify the exit status.
|
|
.Pp
|
|
Functions defined with the
|
|
.Ic function
|
|
reserved word are treated differently in the following ways from functions
|
|
defined with the
|
|
.Ic \&(\&)
|
|
notation:
|
|
.Bl -bullet
|
|
.It
|
|
The
|
|
.Ic $0
|
|
parameter is set to the name of the function (Bourne-style functions leave
|
|
.Ic $0
|
|
untouched).
|
|
.It
|
|
Parameter assignments preceding function calls are not kept in the shell
|
|
environment (executing Bourne-style functions will keep assignments).
|
|
.It
|
|
.Ev OPTIND
|
|
is saved/reset and restored on entry and exit from the function so
|
|
.Ic getopts
|
|
can be used properly both inside and outside the function (Bourne-style
|
|
functions leave
|
|
.Dv OPTIND
|
|
untouched, so using
|
|
.Ic getopts
|
|
inside a function interferes with using
|
|
.Ic getopts
|
|
outside the function).
|
|
In the future, the following differences will also be added:
|
|
.Bl -bullet -offset indent
|
|
.It
|
|
A separate trap/signal environment will be used during the execution of
|
|
functions.
|
|
This will mean that traps set inside a function will not affect the
|
|
shell's traps and signals that are not ignored in the shell (but may be
|
|
trapped) will have their default effect in a function.
|
|
.It
|
|
The EXIT trap, if set in a function, will be executed after the function
|
|
returns.
|
|
.El
|
|
.El
|
|
.Ss POSIX mode
|
|
The shell is intended to be
|
|
.Tn POSIX
|
|
compliant; however, in some cases,
|
|
.Tn POSIX
|
|
behaviour is contrary either to the original Korn shell behaviour or to user
|
|
convenience.
|
|
How the shell behaves in these cases is determined by the state of the
|
|
.Ic posix
|
|
option
|
|
.Pq Ic set Fl o Ic posix .
|
|
If it is on, the
|
|
.Tn POSIX
|
|
behaviour is followed; otherwise, it is not.
|
|
The
|
|
.Ic posix
|
|
option is set automatically when the shell starts up if the environment
|
|
contains the
|
|
.Dv POSIXLY_CORRECT
|
|
parameter.
|
|
.Pp
|
|
The following is a list of things that are affected by the state of the
|
|
.Ic posix
|
|
option:
|
|
.Bl -bullet
|
|
Reading of
|
|
.Ev $ENV .
|
|
If not in
|
|
.Ic posix
|
|
mode, the
|
|
.Ev ENV
|
|
parameter is not expanded and included when the shell starts.
|
|
.It
|
|
Occurrences of
|
|
.Ic \e\&"
|
|
inside double quoted
|
|
.Ic `\&.\&.`
|
|
command substitutions.
|
|
In
|
|
.Tn POSIX
|
|
mode, the
|
|
.Ic \e\&"
|
|
is interpreted when the command is interpreted; in
|
|
.Pf non- Tn POSIX
|
|
mode, the
|
|
backslash is stripped before the command substitution is interpreted.
|
|
For example,
|
|
.Ic echo \&"`echo \e\&"hi\e\&"`\&"
|
|
produces
|
|
.Dq \&"hi\&"
|
|
in
|
|
.Tn POSIX
|
|
mode,
|
|
.Dq hi
|
|
in
|
|
.Pf non- Tn POSIX
|
|
mode.
|
|
To avoid problems, use the
|
|
.Ic $(...)\&
|
|
form of command substitution.
|
|
.It
|
|
.Ic kill -l
|
|
output.
|
|
In
|
|
.Tn POSIX
|
|
mode, signal names are listed one per line; in
|
|
.Pf non- Tn POSIX
|
|
mode,
|
|
signal numbers, names and descriptions are printed in columns.
|
|
In the future, a new option
|
|
.Pq Fl v No perhaps
|
|
will be added to distinguish the two behaviours.
|
|
.It
|
|
.Ic fg
|
|
exit status.
|
|
In
|
|
.Tn POSIX
|
|
mode, the exit status is 0 if no errors occur; in
|
|
.Pf non- Tn POSIX
|
|
mode, the exit status is that of the last foregrounded job.
|
|
.It
|
|
.Ic eval
|
|
exit status.
|
|
If
|
|
.Ic eval
|
|
gets to see an empty command (i.e.,
|
|
.Ic eval "`false`" ) ,
|
|
its exit status in
|
|
.Tn POSIX
|
|
mode will be 0.
|
|
In
|
|
.Pf non- Tn POSIX
|
|
mode, it will be the exit status of the last command substitution that was
|
|
done in the processing of the arguments to
|
|
.Ic eval
|
|
(or 0 if there were no command substitutions).
|
|
.It
|
|
.Ic getopts .
|
|
In
|
|
.Tn POSIX
|
|
mode, options must start with a
|
|
.Ql - ;
|
|
in
|
|
.Pf non- Tn POSIX
|
|
mode, options can start with either
|
|
.Ql -
|
|
or
|
|
.Ql + .
|
|
.It
|
|
Brace expansion (also known as alternation).
|
|
In
|
|
.Tn POSIX
|
|
mode, brace expansion is
|
|
disabled; in
|
|
.Pf non- Tn POSIX
|
|
mode, brace expansion is enabled.
|
|
Note that
|
|
.Ic set Fl o Ic posix
|
|
(or setting the
|
|
.Ev POSIXLY_CORRECT
|
|
parameter) automatically turns the
|
|
.Ic braceexpand
|
|
option off; however, it can be explicitly turned on later.
|
|
.It
|
|
.Ic set \&- .
|
|
In
|
|
.Tn POSIX
|
|
mode, this does not clear the
|
|
.Ic verbose
|
|
or
|
|
.Ic xtrace
|
|
options; in
|
|
.Pf non- Tn POSIX
|
|
mode, it does.
|
|
.It
|
|
.Ic set
|
|
exit status.
|
|
In
|
|
.Tn POSIX
|
|
mode, the exit status of
|
|
.Ic set
|
|
is 0 if there are no errors; in
|
|
.Pf non- Tn POSIX
|
|
mode, the exit status is that of any
|
|
command substitutions performed in generating the
|
|
.Ic set
|
|
command.
|
|
For example,
|
|
.Ic set \&-\&- `false`; echo $?\&
|
|
prints 0 in
|
|
.Tn POSIX
|
|
mode, 1 in
|
|
.Pf non- Tn POSIX
|
|
mode.
|
|
This construct is used in most shell scripts that use the old
|
|
.Xr getopt 1
|
|
command.
|
|
.It
|
|
Argument expansion of the
|
|
.Ic alias ,
|
|
.Ic export ,
|
|
.Ic readonly
|
|
and
|
|
.Ic typeset
|
|
commands.
|
|
In
|
|
.Tn POSIX
|
|
mode, normal argument expansion is done; in
|
|
.Pf non- Tn POSIX
|
|
mode,
|
|
field splitting, file globbing, brace expansion and (normal) tilde expansion
|
|
are turned off, while assignment tilde expansion is turned on.
|
|
.It
|
|
Signal specification.
|
|
In
|
|
.Tn POSIX
|
|
mode, signals can be specified as digits, only
|
|
if signal numbers match
|
|
.Tn POSIX
|
|
values (i.e., HUP=1, INT=2, QUIT=3, ABRT=6,
|
|
KILL=9, ALRM=14 and TERM=15); in
|
|
.Pf non- Tn POSIX
|
|
mode, signals can always be digits.
|
|
.It
|
|
Alias expansion.
|
|
In
|
|
.Tn POSIX
|
|
mode, alias expansion is only carried out when
|
|
reading command words; in
|
|
.Pf non- Tn POSIX
|
|
mode, alias expansion is carried out on any
|
|
word following an alias that ended in a space.
|
|
For example, the following
|
|
.Ic for
|
|
loop
|
|
.Pp
|
|
.Bl -item -offset indent -compact
|
|
.It
|
|
.Ic alias a='for ' i='j'
|
|
.It
|
|
.Xo
|
|
.Ic a i in 1 2; do print i=$i j=$j;
|
|
.Ic done
|
|
.Xc
|
|
.El
|
|
.Pp
|
|
uses parameter
|
|
.Ic i
|
|
in
|
|
.Tn POSIX
|
|
mode,
|
|
.Ic j
|
|
in
|
|
.Pf non- Tn POSIX
|
|
mode.
|
|
.It
|
|
Test.
|
|
In
|
|
.Tn POSIX
|
|
mode, the expression
|
|
.Sq Fl t
|
|
(preceded by some number of
|
|
.Sq Ic \&!
|
|
arguments) is always true as it is a non-zero length string; in
|
|
.Pf non- Tn POSIX
|
|
mode, it tests if file descriptor 1 is a
|
|
.Xr tty 4
|
|
(i.e., the
|
|
.Ar fd
|
|
argument to the
|
|
.Fl t
|
|
test may be left out and defaults to 1).
|
|
.El
|
|
.Ss Strict Bourne shell mode
|
|
When the
|
|
.Ic sh
|
|
option is enabled (see the
|
|
.Ic set
|
|
command),
|
|
.Nm
|
|
will behave like
|
|
.Xr sh 1
|
|
in the following ways:
|
|
.Bl -bullet
|
|
.It
|
|
The parameter
|
|
.Ic $_
|
|
is not set to
|
|
.Bl -dash
|
|
.It
|
|
the expanded alias' full program path after entering commands
|
|
that are tracked aliases
|
|
.It
|
|
the last argument on the command line after entering external
|
|
commands
|
|
.El
|
|
.It
|
|
File descriptors are left untouched when executing
|
|
.Ic exec
|
|
with no arguments.
|
|
.It
|
|
Backslash-escaped special characters are not substituted in
|
|
.Ev PS1 .
|
|
.It
|
|
Sequences of
|
|
.Sq Li (( Ns Ar ... Ns Li ))
|
|
are not interpreted as arithmetic expressions.
|
|
.El
|
|
.Ss Command execution
|
|
After evaluation of command-line arguments, redirections and parameter
|
|
assignments, the type of command is determined: a special built-in, a
|
|
function, a regular built-in or the name of a file to execute found using the
|
|
.Ev PATH
|
|
parameter.
|
|
The checks are made in the above order.
|
|
Special built-in commands differ from other commands in that the
|
|
.Ev PATH
|
|
parameter is not used to find them, and an error during their execution can
|
|
cause a non-interactive shell to exit and parameter assignments that are
|
|
specified before the command are kept after the command completes.
|
|
Just to confuse things, if the
|
|
.Ic posix
|
|
option is turned off (see the
|
|
.Ic set
|
|
command below), some special commands are very special in that no field
|
|
splitting, file globbing, brace expansion, nor tilde expansion is performed
|
|
on arguments that look like assignments.
|
|
Regular built-in commands are different only in that the
|
|
.Ev PATH
|
|
parameter is not used to find them.
|
|
.Pp
|
|
The original
|
|
.Nm ksh
|
|
and
|
|
.Tn POSIX
|
|
differ somewhat in which commands are considered
|
|
special or regular:
|
|
.Pp
|
|
.Tn POSIX
|
|
special commands
|
|
.Pp
|
|
.Ic \&. , \&: , break , continue ,
|
|
.Ic eval , exec , exit , export ,
|
|
.Ic readonly , return , set , shift ,
|
|
.Ic trap , unset
|
|
.Pp
|
|
Additional
|
|
.Nm
|
|
special commands
|
|
.Pp
|
|
.Ic builtin , times , typeset
|
|
.Pp
|
|
Very special commands
|
|
.Pq Pf non- Tn POSIX
|
|
.Pp
|
|
.Ic alias , readonly , set , typeset
|
|
.Pp
|
|
.Tn POSIX
|
|
regular commands
|
|
.Pp
|
|
.Ic alias , bg , cd , command ,
|
|
.Ic false , fc , fg , getopts ,
|
|
.Ic jobs , kill , read , true ,
|
|
.Ic umask , unalias , wait
|
|
.Pp
|
|
Additional
|
|
.Nm
|
|
regular commands
|
|
.Pp
|
|
.Ic \&[ , echo , let , print ,
|
|
.Ic pwd , test , ulimit , whence
|
|
.Pp
|
|
In the future, the additional
|
|
.Nm
|
|
special and regular commands may be treated
|
|
differently from the
|
|
.Tn POSIX
|
|
special and regular commands.
|
|
.Pp
|
|
Once the type of the command has been determined, any command-line parameter
|
|
assignments are performed and exported for the duration of the command.
|
|
.Pp
|
|
The following describes the special and regular built-in commands:
|
|
.Bl -tag -width Ds
|
|
.It Ic \&. Ar file Op Ar arg1 ...
|
|
Execute the commands in
|
|
.Ar file
|
|
in the current environment.
|
|
The file is searched for in the directories of
|
|
.Ev PATH .
|
|
If arguments are given, the positional parameters may be used to access them
|
|
while
|
|
.Ar file
|
|
is being executed.
|
|
If no arguments are given, the positional parameters are
|
|
those of the environment the command is used in.
|
|
.It Ic \&: Op Ar ...
|
|
The null command.
|
|
Exit status is set to zero.
|
|
.It Xo Ic alias
|
|
.Op Fl d | Ic +-t Op Fl r
|
|
.Op Ic +-px
|
|
.Op Ic +-
|
|
.Oo Ar name
|
|
.Op Ns = Ns Ar value
|
|
.Ar ... Oc
|
|
.Xc
|
|
Without arguments,
|
|
.Ic alias
|
|
lists all aliases.
|
|
For any name without a value, the existing alias is listed.
|
|
Any name with a value defines an alias (see
|
|
.Sx Aliases
|
|
above).
|
|
.Pp
|
|
When listing aliases, one of two formats is used.
|
|
Normally, aliases are listed as
|
|
.Ar name Ns = Ns Ar value ,
|
|
where
|
|
.Ar value
|
|
is quoted.
|
|
If options were preceded with
|
|
.Ql +
|
|
or a lone
|
|
.Ql +
|
|
is given on the command line, only
|
|
.Ar name
|
|
is printed.
|
|
In addition, if the
|
|
.Fl p
|
|
option is used, each alias is prefixed with the string
|
|
.Dq alias\ \& .
|
|
.Pp
|
|
The
|
|
.Fl x
|
|
option sets
|
|
.Po Ic \&+x
|
|
\ clears
|
|
.Pc
|
|
the export attribute of an alias or, if no names are given, lists the aliases
|
|
with the export attribute (exporting an alias has no effect).
|
|
.Pp
|
|
The
|
|
.Fl t
|
|
option indicates that tracked aliases are to be listed/set (values specified on
|
|
the command line are ignored for tracked aliases).
|
|
The
|
|
.Fl r
|
|
option indicates that all tracked aliases are to be reset.
|
|
.Pp
|
|
The
|
|
.Fl d
|
|
option causes directory aliases, which are used in tilde expansion, to be
|
|
listed or set (see
|
|
.Sx Tilde expansion
|
|
above).
|
|
.It Ic bg Op Ar job ...
|
|
Resume the specified stopped job(s) in the background.
|
|
If no jobs are specified,
|
|
.Ic %\&+
|
|
is assumed.
|
|
This command is only available on systems which support job control (see
|
|
.Sx Job control
|
|
below for more information).
|
|
.It Ic bind Op Fl l
|
|
The current bindings or, if the
|
|
.Fl l
|
|
flag is given,
|
|
the names of the functions to which keys may be bound, are listed.
|
|
See
|
|
.Sx Emacs editing mode
|
|
for more information.
|
|
.It Xo Ic bind Op Fl m
|
|
.Ar string Ns = Ns Op Ar substitute
|
|
.Ar ...
|
|
.Xc
|
|
.It Xo Ic bind
|
|
.Ar string Ns = Ns Op Ar editing-command
|
|
.Ar ...
|
|
.Xc
|
|
The specified editing command is bound to the given
|
|
.Ar string ,
|
|
which should consist of a control character (which may be written using caret
|
|
notation, i.e., ^X), optionally preceded by one of the two prefix characters.
|
|
If the
|
|
.Fl m
|
|
flag is given, the specified input
|
|
.Ar string
|
|
will afterwards be immediately replaced by the given
|
|
.Ar substitute
|
|
string, which may contain editing commands.
|
|
.Pp
|
|
Future input of the
|
|
.Ar string
|
|
will cause the editing command to be immediately invoked.
|
|
Note that although only two prefix characters (usually
|
|
.Tn ESC
|
|
and ^X) are supported, some
|
|
multi-character sequences can be supported.
|
|
The following binds the arrow keys on an
|
|
.Tn ANSI
|
|
terminal or
|
|
.Xr xterm 1
|
|
(these are in the default bindings).
|
|
Of course some escape sequences won't work out quite this nicely.
|
|
.Pp
|
|
.Bl -item -compact
|
|
.It
|
|
.Ic bind '^[['=prefix-2
|
|
.It
|
|
.Ic bind '^XA'=up-history
|
|
.It
|
|
.Ic bind '^XB'=down-history
|
|
.It
|
|
.Ic bind '^XC'=forward-char
|
|
.It
|
|
.Ic bind '^XD'=backward-char
|
|
.El
|
|
.It Ic break Op Ar level
|
|
Exit the
|
|
.Ar level Ns th
|
|
inner-most
|
|
.Ic for ,
|
|
.Ic select ,
|
|
.Ic until
|
|
or
|
|
.Ic while
|
|
loop.
|
|
.Ar level
|
|
defaults to 1.
|
|
.It Ic builtin Ar command Op Ar arg1 ...
|
|
Execute the built-in command
|
|
.Ar command .
|
|
.It Xo Ic cd Op Fl LP
|
|
.Op Ar dir
|
|
.Xc
|
|
Set the working directory to
|
|
.Ar dir .
|
|
If the parameter
|
|
.Ev CDPATH
|
|
is set, it lists the search path for the directory containing
|
|
.Ar dir .
|
|
A
|
|
.Dv NULL
|
|
path means the current directory.
|
|
If
|
|
.Ar dir
|
|
is found in any component of the
|
|
.Ev CDPATH
|
|
search path other than the
|
|
.Dv NULL
|
|
path, the name of the new working directory will be written to standard output.
|
|
If
|
|
.Ar dir
|
|
is missing, the home directory
|
|
.Ev HOME
|
|
is used.
|
|
If
|
|
.Ar dir
|
|
is
|
|
.Ql - ,
|
|
the previous working directory is used (see
|
|
.Ev OLDPWD
|
|
parameter).
|
|
If the
|
|
.Fl L
|
|
option (logical path) is used or if the
|
|
.Ic physical
|
|
option (see the
|
|
.Ic set
|
|
command below) isn't set, references to
|
|
.Dq \&.\&.
|
|
in
|
|
.Ar dir
|
|
are relative to the path used to get to the directory.
|
|
If the
|
|
.Fl P
|
|
option (physical path) is used or if the
|
|
.Ic physical
|
|
option is set,
|
|
.Dq \&.\&.
|
|
is relative to the filesystem directory tree.
|
|
The
|
|
.Ev PWD
|
|
and
|
|
.Ev OLDPWD
|
|
parameters are updated to reflect the current and old working directory,
|
|
respectively.
|
|
.It Xo Ic cd Op Fl LP
|
|
.Ar old new
|
|
.Xc
|
|
The string
|
|
.Ar new
|
|
is substituted for
|
|
.Ar old
|
|
in the current directory, and the shell attempts to change to the new
|
|
directory.
|
|
.It Xo Ic command Op Fl pvV
|
|
.Ar cmd Op Ar arg1 ...
|
|
.Xc
|
|
If neither the
|
|
.Fl v
|
|
nor
|
|
.Fl V
|
|
option is given,
|
|
.Ar cmd
|
|
is executed exactly as if
|
|
.Ic command
|
|
had not been specified, with two exceptions.
|
|
First,
|
|
.Ar cmd
|
|
cannot be a shell function, and second, special built-in commands lose their
|
|
specialness (i.e., redirection and utility errors do not cause the shell to
|
|
exit, and command assignments are not permanent).
|
|
If the
|
|
.Fl p
|
|
option is given, a default search path is used instead of the current value of
|
|
.Ev PATH
|
|
(the actual value of the default path is system dependent: on
|
|
.Tn POSIX Ns ish
|
|
systems, it is the value returned by
|
|
.Ic getconf CS_PATH ) .
|
|
.Pp
|
|
If the
|
|
.Fl v
|
|
option is given, instead of executing
|
|
.Ar cmd ,
|
|
information about what would be executed is given (and the same is done for
|
|
.Ar arg1 ... ) .
|
|
For special and regular built-in commands and functions, their names are simply
|
|
printed; for aliases, a command that defines them is printed; and for commands
|
|
found by searching the
|
|
.Ev PATH
|
|
parameter, the full path of the command is printed.
|
|
If no command is found
|
|
(i.e., the path search fails), nothing is printed and
|
|
.Ic command
|
|
exits with a non-zero status.
|
|
The
|
|
.Fl V
|
|
option is like the
|
|
.Fl v
|
|
option, except it is more verbose.
|
|
.It Ic continue Op Ar level
|
|
Jumps to the beginning of the
|
|
.Ar level Ns th
|
|
inner-most
|
|
.Ic for ,
|
|
.Ic select ,
|
|
.Ic until
|
|
or
|
|
.Ic while
|
|
loop.
|
|
.Ar level
|
|
defaults to 1.
|
|
.It Xo Ic echo Op Fl neE
|
|
.Op Ar arg ...
|
|
.Xc
|
|
Prints its arguments (separated by spaces) followed by a newline, to the
|
|
standard output.
|
|
The newline is suppressed if any of the arguments contain the
|
|
backslash sequence
|
|
.Ql \ec .
|
|
See the
|
|
.Ic print
|
|
command below for a list of other backslash sequences that are recognized.
|
|
.Pp
|
|
The options are provided for compatibility with
|
|
.Bx
|
|
shell scripts.
|
|
The
|
|
.Fl n
|
|
option suppresses the trailing newline,
|
|
.Fl e
|
|
enables backslash interpretation (a no-op, since this is normally done), and
|
|
.Fl E
|
|
suppresses backslash interpretation.
|
|
.It Ic eval Ar command ...
|
|
The arguments are concatenated (with spaces between them) to form a single
|
|
string which the shell then parses and executes in the current environment.
|
|
.It Xo Ic exec
|
|
.Op Ar command Op Ar arg ...
|
|
.Xc
|
|
The command is executed without forking, replacing the shell process.
|
|
.Pp
|
|
If no command is given except for I/O redirection, the I/O redirection is
|
|
permanent and the shell is
|
|
not replaced.
|
|
Any file descriptors greater than 2 which are opened or
|
|
.Xr dup 2 Ns 'd
|
|
in this way are not made available to other executed commands (i.e., commands
|
|
that are not built-in to the shell).
|
|
Note that the Bourne shell differs here;
|
|
it does pass these file descriptors on.
|
|
.It Ic exit Op Ar status
|
|
The shell exits with the specified exit status.
|
|
If
|
|
.Ar status
|
|
is not specified, the exit status is the current value of the
|
|
.Ic $\&?
|
|
parameter.
|
|
.It Xo Ic export Op Fl p
|
|
.Op Ar parameter Ns Op \&= Ns Ar value
|
|
.Xc
|
|
Sets the export attribute of the named parameters.
|
|
Exported parameters are passed in the environment to executed commands.
|
|
If values are specified, the named parameters are also assigned.
|
|
.Pp
|
|
If no parameters are specified, the names of all parameters with the export
|
|
attribute are printed one per line, unless the
|
|
.Fl p
|
|
option is used, in which case
|
|
.Ic export
|
|
commands defining all exported parameters, including their values, are printed.
|
|
.It Ic false
|
|
A command that exits with a non-zero status.
|
|
.It Xo Ic fc
|
|
.Oo Fl e Ar editor \*(Ba
|
|
.Fl l Op Fl n Oc
|
|
.Op Fl r
|
|
.Op Ar first Op Ar last
|
|
.Xc
|
|
.Ar first
|
|
and
|
|
.Ar last
|
|
select commands from the history.
|
|
Commands can be selected by history number
|
|
or a string specifying the most recent command starting with that string.
|
|
The
|
|
.Fl l
|
|
option lists the command on stdout, and
|
|
.Fl n
|
|
inhibits the default command numbers.
|
|
The
|
|
.Fl r
|
|
option reverses the order of the list.
|
|
Without
|
|
.Fl l ,
|
|
the selected commands are edited by the editor specified with the
|
|
.Fl e
|
|
option, or if no
|
|
.Fl e
|
|
is specified, the editor specified by the
|
|
.Ev FCEDIT
|
|
parameter (if this parameter is not set,
|
|
.Pa /bin/ed
|
|
is used), and then executed by the shell.
|
|
.It Xo Ic fc
|
|
.Oo Fl e No \&- \&| Fl s Oc
|
|
.Op Fl g
|
|
.Op Ar old Ns = Ns Ar new
|
|
.Op Ar prefix
|
|
.Xc
|
|
Re-execute the selected command (the previous command by default) after
|
|
performing the optional substitution of
|
|
.Ar old
|
|
with
|
|
.Ar new .
|
|
If
|
|
.Fl g
|
|
is specified, all occurrences of
|
|
.Ar old
|
|
are replaced with
|
|
.Ar new .
|
|
This command is usually accessed with the predefined
|
|
.Ic alias r='fc -e -' .
|
|
.It Ic fg Op Ar job ...
|
|
Resume the specified job(s) in the foreground.
|
|
If no jobs are specified,
|
|
.Ic %\&+
|
|
is assumed.
|
|
This command is only available on systems which support job control (see
|
|
.Sx Job control
|
|
below for more information).
|
|
.It Xo Ic getopts Ar optstring name
|
|
.Op Ar arg ...
|
|
.Xc
|
|
Used by shell procedures to parse the specified arguments (or positional
|
|
parameters, if no arguments are given) and to check for legal options.
|
|
.Ar optstring
|
|
contains the option letters that
|
|
.Ic getopts
|
|
is to recognize.
|
|
If a letter is followed by a colon, the option is expected to
|
|
have an argument.
|
|
Options that do not take arguments may be grouped in a single argument.
|
|
If an option takes an argument and the option character is not the
|
|
last character of the argument it is found in, the remainder of the argument is
|
|
taken to be the option's argument; otherwise, the next argument is the option's
|
|
argument.
|
|
.Pp
|
|
Each time
|
|
.Ic getopts
|
|
is invoked, it places the next option in the shell parameter
|
|
.Ar name
|
|
and the index of the next argument to be processed in the shell parameter
|
|
.Ev OPTIND .
|
|
If the option was introduced with a
|
|
.Ql + ,
|
|
the option placed in
|
|
.Ar name
|
|
is prefixed with a
|
|
.Ql + .
|
|
When an option requires an argument,
|
|
.Ic getopts
|
|
places it in the shell parameter
|
|
.Ev OPTARG .
|
|
When an illegal option or a missing option argument is encountered, a question
|
|
mark or a colon is placed in
|
|
.Ar name
|
|
(indicating an illegal option or missing argument, respectively) and
|
|
.Ev OPTARG
|
|
is set to the option character that caused the problem.
|
|
If
|
|
.Ar optstring
|
|
does not begin with a colon, a question mark is placed in
|
|
.Ar name ,
|
|
.Ev OPTARG
|
|
is unset and an error message is printed to standard error.
|
|
.Pp
|
|
When the end of the options is encountered,
|
|
.Ic getopts
|
|
exits with a non-zero exit status.
|
|
Options end at the first (non-option
|
|
argument) argument that does not start with a
|
|
.Ql -
|
|
or when a
|
|
.Ql --
|
|
argument is encountered.
|
|
.Pp
|
|
Option parsing can be reset by setting
|
|
.Ev OPTIND
|
|
to 1 (this is done automatically whenever the shell or a shell procedure is
|
|
invoked).
|
|
.Pp
|
|
Warning: Changing the value of the shell parameter
|
|
.Ev OPTIND
|
|
to a value other than 1 or parsing different sets of arguments without
|
|
resetting
|
|
.Ev OPTIND
|
|
may lead to unexpected results.
|
|
.It Xo Ic hash Op Fl r
|
|
.Op Ar name ...
|
|
.Xc
|
|
Without arguments, any hashed executable command pathnames are listed.
|
|
The
|
|
.Fl r
|
|
option causes all hashed commands to be removed from the hash table.
|
|
Each
|
|
.Ar name
|
|
is searched as if it were a command name and added to the hash table if it is
|
|
an executable command.
|
|
.It Xo Ic jobs Op Fl lpn
|
|
.Op Ar job ...
|
|
.Xc
|
|
Display information about the specified job(s); if no jobs are specified, all
|
|
jobs are displayed.
|
|
The
|
|
.Fl n
|
|
option causes information to be displayed only for jobs that have changed
|
|
state since the last notification.
|
|
If the
|
|
.Fl l
|
|
option is used, the process ID of each process in a job is also listed.
|
|
The
|
|
.Fl p
|
|
option causes only the process group of each job to be printed.
|
|
See
|
|
.Sx Job control
|
|
below for the format of
|
|
.Ar job
|
|
and the displayed job.
|
|
.It Xo Ic kill
|
|
.Oo Fl s Ar signame \*(Ba
|
|
.Fl Ar signum | Fl Ar signame Oc {
|
|
.Ar job |
|
|
.Ar pid |
|
|
.Ar pgrp No } Ar ...
|
|
.Xc
|
|
Send the specified signal to the specified jobs, process IDs or process
|
|
groups.
|
|
If no signal is specified, the
|
|
.Dv TERM
|
|
signal is sent.
|
|
If a job is specified, the signal is sent to the job's process group.
|
|
See
|
|
.Sx Job control
|
|
below for the format of
|
|
.Ar job .
|
|
.It Ic kill -l Op Ar exit-status ...
|
|
Print the name of the signal that killed a process which exited with the
|
|
specified
|
|
.Ar exit-status Ns es.
|
|
If no arguments are specified, a list of all the signals, their numbers and
|
|
a short description of them are printed.
|
|
.It Ic let Op Ar expression ...
|
|
Each expression is evaluated (see
|
|
.Sx Arithmetic expressions
|
|
above).
|
|
If all expressions are successfully evaluated, the exit status is 0 (1)
|
|
if the last expression evaluated to non-zero (zero).
|
|
If an error occurs during
|
|
the parsing or evaluation of an expression, the exit status is greater than 1.
|
|
Since expressions may need to be quoted,
|
|
.Ic (( Ar expr Ic ))
|
|
is syntactic sugar for
|
|
.Ic let \&" Ns Ar expr Ns Ic \&" .
|
|
.It Xo Ic print
|
|
.Oo Fl nprsu Ns Ar n \*(Ba
|
|
.Fl R Op Fl en Oc
|
|
.Op Ar argument ...
|
|
.Xc
|
|
.Ic print
|
|
prints its arguments on the standard output, separated by spaces and
|
|
terminated with a newline.
|
|
The
|
|
.Fl n
|
|
option suppresses the newline.
|
|
By default, certain C escapes are translated.
|
|
These include
|
|
.Ql \eb ,
|
|
.Ql \ef ,
|
|
.Ql \en ,
|
|
.Ql \er ,
|
|
.Ql \et ,
|
|
.Ql \ev
|
|
and
|
|
.Ql \e0###
|
|
.Po
|
|
.Ql #
|
|
is an octal digit, of which there may be 0 to 3
|
|
.Pc .
|
|
.Ql \ec
|
|
is equivalent to using the
|
|
.Fl n
|
|
option.
|
|
.Ql \e
|
|
expansion may be inhibited with the
|
|
.Fl r
|
|
option.
|
|
The
|
|
.Fl s
|
|
option prints to the history file instead of standard output, the
|
|
.Fl u
|
|
option prints to file descriptor
|
|
.Ar n
|
|
.Po
|
|
.Ar n
|
|
defaults to 1 if omitted
|
|
.Pc ,
|
|
and the
|
|
.Fl p
|
|
option prints to the co-process (see
|
|
.Sx Co-processes
|
|
above).
|
|
.Pp
|
|
The
|
|
.Fl R
|
|
option is used to emulate, to some degree, the
|
|
.Bx
|
|
.Xr echo 1
|
|
command, which does not process
|
|
.Ql \e
|
|
sequences unless the
|
|
.Fl e
|
|
option is given.
|
|
As above, the
|
|
.Fl n
|
|
option suppresses the trailing newline.
|
|
.It Ic pwd Op Fl LP
|
|
Print the present working directory.
|
|
If the
|
|
.Fl L
|
|
option is used or if the
|
|
.Ic physical
|
|
option (see the
|
|
.Ic set
|
|
command below) isn't set, the logical path is printed (i.e., the path used to
|
|
.Ic cd
|
|
to the current directory).
|
|
If the
|
|
.Fl P
|
|
option (physical path) is used or if the
|
|
.Ic physical
|
|
option is set, the path determined from the filesystem (by following
|
|
.Dq \&.\&.
|
|
directories to the root directory) is printed.
|
|
.It Xo Ic read Oo Fl prsu Ns Ar n
|
|
.Oc Op Ar parameter ...
|
|
.Xc
|
|
Reads a line of input from the standard input, separates the line into fields
|
|
using the
|
|
.Ev IFS
|
|
parameter (see
|
|
.Sx Substitution
|
|
above) and assigns each field to the specified parameters.
|
|
If there are more parameters than fields, the extra parameters are set to
|
|
.Dv NULL ,
|
|
or alternatively, if there are more fields than parameters, the last parameter
|
|
is assigned the remaining fields (inclusive of any separating spaces).
|
|
If no parameters are specified, the
|
|
.Ev REPLY
|
|
parameter is used.
|
|
If the input line ends in a backslash and the
|
|
.Fl r
|
|
option was not used, the backslash and the newline are stripped and more input
|
|
is read.
|
|
If no input is read,
|
|
.Ic read
|
|
exits with a non-zero status.
|
|
.Pp
|
|
The first parameter may have a question mark and a string appended to it, in
|
|
which case the string is used as a prompt (printed to standard error before
|
|
any input is read) if the input is a
|
|
.Xr tty 4
|
|
(e.g.,
|
|
.Ic read nfoo?'number of foos: ' ) .
|
|
.Pp
|
|
The
|
|
.Fl u Ns Ar n
|
|
and
|
|
.Fl p
|
|
options cause input to be read from file descriptor
|
|
.Ar n
|
|
or the current co-process (see
|
|
.Sx Co-processes
|
|
above for comments on this), respectively.
|
|
If the
|
|
.Fl s
|
|
option is used, input is saved to the history file.
|
|
.It Xo Ic readonly Op Fl p
|
|
.Oo Ar parameter
|
|
.Op Ns = Ns Ar value
|
|
.Ar ... Oc
|
|
.Xc
|
|
Sets the read-only attribute of the named parameters.
|
|
If values are given,
|
|
parameters are set to them before setting the attribute.
|
|
Once a parameter is
|
|
made read-only, it cannot be unset and its value cannot be changed.
|
|
.Pp
|
|
If no parameters are specified, the names of all parameters with the read-only
|
|
attribute are printed one per line, unless the
|
|
.Fl p
|
|
option is used, in which case
|
|
.Ic readonly
|
|
commands defining all read-only parameters, including their values, are
|
|
printed.
|
|
.It Ic return Op Ar status
|
|
Returns from a function or
|
|
.Ic \&.
|
|
script, with exit status
|
|
.Ar status .
|
|
If no
|
|
.Ar status
|
|
is given, the exit status of the last executed command is used.
|
|
If used outside of a function or
|
|
.Ic \&.
|
|
script, it has the same effect as
|
|
.Ic exit .
|
|
Note that
|
|
.Nm
|
|
treats both profile and
|
|
.Ev ENV
|
|
files as
|
|
.Ic \&.
|
|
scripts, while the original Korn shell only treats profiles as
|
|
.Ic \&.
|
|
scripts.
|
|
.It Xo Ic set Op Ic +-abCefhkmnpsuvxX
|
|
.Op Ic +-o Ar option
|
|
.Op Ic +-A Ar name
|
|
.Op Fl \&-
|
|
.Op Ar arg ...
|
|
.Xc
|
|
The
|
|
.Ic set
|
|
command can be used to set
|
|
.Pq Ic \&-
|
|
or clear
|
|
.Pq Ic \&+
|
|
shell options, set the positional parameters or set an array parameter.
|
|
Options can be changed using the
|
|
.Ic \&+ Ns Fl o Ar option
|
|
syntax, where
|
|
.Ar option
|
|
is the long name of an option, or using the
|
|
.Ic \&+\&- Ns Ar letter
|
|
syntax, where
|
|
.Ar letter
|
|
is the option's single letter name (not all options have a single letter name).
|
|
The following table lists both option letters (if they exist) and long names
|
|
along with a description of what the option does:
|
|
.Bl -tag -width 15n
|
|
.It Fl A
|
|
Sets the elements of the array parameter
|
|
.Ar name
|
|
to
|
|
.Ar arg ... .
|
|
If
|
|
.Fl A
|
|
is used, the array is reset (i.e., emptied) first; if
|
|
.Ic \&+A
|
|
is used, the first N elements are set (where N is the number of
|
|
.Ar arg Ns s ) ,
|
|
the rest are left untouched.
|
|
.It Fl a Ic allexport
|
|
All new parameters are created with the export attribute.
|
|
.It Fl b Ic notify
|
|
Print job notification messages asynchronously, instead of just before the
|
|
prompt.
|
|
Only used if job control is enabled
|
|
.Pq Fl m .
|
|
.It Fl C Ic noclobber
|
|
Prevent
|
|
.Ic \&>
|
|
redirection from overwriting existing files
|
|
.Po
|
|
.Ic \&>\&|
|
|
must be used to force an overwrite
|
|
.Pc .
|
|
.It Fl e Ic errexit
|
|
Exit (after executing the
|
|
.Dv ERR
|
|
trap) as soon as an error occurs or a command fails (i.e., exits with a
|
|
non-zero status).
|
|
This does not apply to commands whose exit status is
|
|
explicitly tested by a shell construct such as
|
|
.Ic if ,
|
|
.Ic until ,
|
|
.Ic while ,
|
|
.Ic \&&\&&
|
|
or
|
|
.Ic \&|\&|
|
|
statements.
|
|
.It Fl f Ic noglob
|
|
Do not expand file name patterns.
|
|
.It Fl h Ic trackall
|
|
Create tracked aliases for all executed commands (see
|
|
.Sx Aliases
|
|
above).
|
|
Enabled by default for non-interactive shells.
|
|
.It Fl i Ic interactive
|
|
Enable interactive mode.
|
|
This can only be set/unset when the shell is invoked.
|
|
.It Fl k Ic keyword
|
|
Parameter assignments are recognized anywhere in a command.
|
|
.It Fl l Ic login
|
|
The shell is a login shell.
|
|
This can only be set/unset when the shell is invoked (see
|
|
.Sx Shell startup
|
|
above).
|
|
.It Fl m Ic monitor
|
|
Enable job control (default for interactive shells).
|
|
.It Fl n lc noexec
|
|
Do not execute any commands.
|
|
Useful for checking the syntax of scripts
|
|
(ignored if interactive).
|
|
.It Fl p Ic privileged
|
|
Set automatically if, when the shell starts, the read UID or GID does not match
|
|
the effective UID (EUID) or GID (EGID), respectively.
|
|
See
|
|
.Sx Shell startup
|
|
above for a description of what this means.
|
|
.It Fl r Ic restricted
|
|
Enable restricted mode.
|
|
This option can only be used when the shell is invoked.
|
|
See
|
|
.Sx Shell startup
|
|
above for a description of what this means.
|
|
.It Fl s Ic stdin
|
|
If used where the shell is invoked, commands are read from standard input.
|
|
Set automatically if the shell is invoked with no arguments.
|
|
.Pp
|
|
When
|
|
.Fl s
|
|
is used with the
|
|
.Ic set
|
|
command it causes the specified arguments to be sorted before assigning them to
|
|
the positional parameters (or to array
|
|
.Ar name ,
|
|
if
|
|
.Fl A
|
|
is used).
|
|
.It Fl u Ic nounset
|
|
Referencing of an unset parameter is treated as an error, unless one of the
|
|
.Ql - ,
|
|
.Ql +
|
|
or
|
|
.Ql =
|
|
modifiers is used.
|
|
.It Fl v Ic verbose
|
|
Write shell input to standard error as it is read.
|
|
.It Fl x Ic xtrace
|
|
Print commands and parameter assignments when they are executed, preceded by
|
|
the value of
|
|
.Ev PS4 .
|
|
.It Fl X Ic markdirs
|
|
Mark directories with a trailing
|
|
.Ql /
|
|
during file name generation.
|
|
.It Ic bgnice
|
|
Background jobs are run with lower priority.
|
|
.It Ic braceexpand
|
|
Enable brace expansion (a.k.a., alternation).
|
|
.It Ic emacs
|
|
Enable BRL emacs-like command-line editing (interactive shells only); see
|
|
.Sx Emacs editing mode .
|
|
.It Ic emacs-usemeta
|
|
In emacs command-line editing, use the 8th bit as meta (^[) prefix.
|
|
This is the default.
|
|
.It Ic gmacs
|
|
Enable gmacs-like command-line editing (interactive shells only).
|
|
Currently identical to emacs editing except that transpose (^T) acts slightly
|
|
differently.
|
|
.It Ic ignoreeof
|
|
The shell will not (easily) exit when end-of-file is read;
|
|
.Ic exit
|
|
must be used.
|
|
To avoid infinite loops, the shell will exit if
|
|
.Dv EOF
|
|
is read 13 times in a row.
|
|
.It Ic nohup
|
|
Do not kill running jobs with a
|
|
.Dv SIGHUP
|
|
signal when a login shell exists.
|
|
Currently set by default, but this will
|
|
change in the future to be compatible with the original Korn shell (which
|
|
doesn't have this option, but does send the
|
|
.Dv SIGHUP
|
|
signal).
|
|
.It Ic nolog
|
|
No effect.
|
|
In the original Korn shell, this prevents function definitions from
|
|
being stored in the history file.
|
|
.It Ic physical
|
|
Causes the
|
|
.Ic cd
|
|
and
|
|
.Ic pwd
|
|
commands to use
|
|
.Dq physical
|
|
(i.e., the filesystem's)
|
|
.Dq \&.\&.
|
|
directories instead of
|
|
.Dq logical
|
|
directories (i.e., the shell handles
|
|
.Dq \&.\&. ,
|
|
which allows the user to be oblivious of symbolic links to directories).
|
|
Clear by default.
|
|
Note that setting this option does not affect the current value of the
|
|
.Ev PWD
|
|
parameter; only the
|
|
.Ic cd
|
|
command changes
|
|
.Ev PWD .
|
|
See the
|
|
.Ic cd
|
|
and
|
|
.Ic pwd
|
|
commands above for more details.
|
|
.It Ic posix
|
|
Enable
|
|
.Tn POSIX
|
|
mode.
|
|
See
|
|
.Sx POSIX mode
|
|
above.
|
|
.It Ic sh
|
|
Enable strict Bourne shell mode (see
|
|
.Sx Strict Bourne shell mode ) .
|
|
.It Ic vi
|
|
Enable
|
|
.Xr vi 1 Ns -like
|
|
command-line editing (interactive shells only).
|
|
.It Ic viraw
|
|
No effect.
|
|
In the original Korn shell, unless
|
|
.Ic viraw
|
|
was set, the vi command-line mode would let the
|
|
.Xr tty 4
|
|
driver do the work until
|
|
.Tn ESC
|
|
(^[) was entered.
|
|
.Nm
|
|
is always in viraw mode.
|
|
.It Ic vi-esccomplete
|
|
In vi command-line editing, do command and file name completion when escape
|
|
(^[) is entered in command mode.
|
|
.It Ic vi-show8
|
|
Prefix characters with the eighth bit set with
|
|
.Dq M\&- .
|
|
If this option is not set, characters in the range 128\-160 are printed as is,
|
|
which may cause problems.
|
|
.It Ic vi-tabcomplete
|
|
In vi command-line editing, do command and file name completion when tab (^I)
|
|
is entered in insert mode.
|
|
This is the default.
|
|
.El
|
|
.Pp
|
|
These options can also be used upon invocation of the shell.
|
|
The current set of
|
|
options (with single letter names) can be found in the parameter
|
|
.Dv \&- .
|
|
.Ic set Fl o
|
|
with no option name will list all the options and whether each is on or off;
|
|
.Ic set +o
|
|
will print the long names of all options that are currently on.
|
|
.Pp
|
|
Remaining arguments, if any, are positional parameters and are assigned, in
|
|
order, to the positional parameters (i.e.
|
|
.Ic $1 , $2 ,
|
|
etc.).
|
|
If options end with
|
|
.Ql --
|
|
and there are no remaining arguments, all positional parameters are cleared.
|
|
If no options or arguments are given, the values of all names are printed.
|
|
For unknown historical reasons, a lone
|
|
.Ql -
|
|
option is treated specially \(em it clears both the
|
|
.Fl x
|
|
and
|
|
.Fl v
|
|
options.
|
|
.It Ic shift Op Ar number
|
|
The positional parameters
|
|
.Ar number Ns +1 ,
|
|
.Ar number Ns +2 ,
|
|
etc. are renamed to
|
|
.Dq 1 ,
|
|
.Dq 2 ,
|
|
etc.
|
|
.Ar number
|
|
defaults to 1.
|
|
.It Ic test Ar expression
|
|
.It Ic \&[ Ar expression Ic \&]
|
|
.Ic test
|
|
evaluates the
|
|
.Ar expression
|
|
and returns zero status if true, 1 if false, or greater than 1 if there
|
|
was an error.
|
|
It is normally used as the condition command of
|
|
.Ic if
|
|
and
|
|
.Ic while
|
|
statements.
|
|
The following basic expressions are available:
|
|
.Bl -tag -width 17n
|
|
.It Fl r Ar file
|
|
.Ar file
|
|
exists and is readable.
|
|
.It Fl w Ar file
|
|
.Ar file
|
|
exists and is writable.
|
|
.It Fl x Ar file
|
|
.Ar file
|
|
exists and is executable.
|
|
.It Fl a Ar file
|
|
.Ar file
|
|
exists.
|
|
.It Fl e Ar file
|
|
.Ar file
|
|
exists.
|
|
.It Fl f Ar file
|
|
.Ar file
|
|
is a regular file.
|
|
.It Fl d Ar file
|
|
.Ar file
|
|
is a directory.
|
|
.It Fl c Ar file
|
|
.Ar file
|
|
is a character special device.
|
|
.It Fl b Ar file
|
|
.Ar file
|
|
is a block special device.
|
|
.It Fl p Ar file
|
|
.Ar file
|
|
is a named pipe.
|
|
.It Fl u Ar file
|
|
.Ar file Ns 's
|
|
mode has setuid bit set.
|
|
.It Fl g Ar file
|
|
.Ar file Ns 's
|
|
mode has setgid bit set.
|
|
.It Fl k Ar file
|
|
.Ar file Ns 's
|
|
mode has sticky bit set.
|
|
.It Fl s Ar file
|
|
.Ar file
|
|
is not empty.
|
|
.It Fl O Ar file
|
|
.Ar file Ns 's
|
|
owner is the shell's effective user ID.
|
|
.It Fl G Ar file
|
|
.Ar file Ns 's
|
|
group is the shell's effective group ID.
|
|
.It Fl h Ar file
|
|
.Ar file
|
|
is a symbolic link.
|
|
.It Fl H Ar file
|
|
.Ar file
|
|
is a context dependent directory (only useful on HP-UX).
|
|
.It Fl L Ar file
|
|
.Ar file
|
|
is a symbolic link.
|
|
.It Fl S Ar file
|
|
.Ar file
|
|
is a socket.
|
|
.It Fl o Ar option
|
|
Shell
|
|
.Ar option
|
|
is set (see the
|
|
.Ic set
|
|
command above for a list of options).
|
|
As a non-standard extension, if the option starts with a
|
|
.Ql \&! ,
|
|
the test is negated; the test always fails if
|
|
.Ar option
|
|
doesn't exist (thus
|
|
.Ic \&[ -o Ar foo
|
|
.Ic -o -o \&! Ns Ar foo Ic \&]
|
|
returns true if and only if option
|
|
.Ar foo
|
|
exists).
|
|
.It Ar file1 Fl nt Ar file2
|
|
.Ar file1
|
|
is newer than
|
|
.Ar file2 .
|
|
.It Ar file1 Fl ot Ar file2
|
|
.Ar file1
|
|
is older than
|
|
.Ar file2 .
|
|
.It Ar file1 Fl ef Ar file2
|
|
.Ar file1
|
|
is the same file as
|
|
.Ar file2 .
|
|
.It Fl t Op Ar fd
|
|
File descriptor
|
|
.Ar fd
|
|
is a
|
|
.Xr tty 4
|
|
device.
|
|
If the
|
|
.Ic posix
|
|
option is not set,
|
|
.Ar fd
|
|
may be left out, in which case it is taken to be 1 (the behaviour differs due
|
|
to the special
|
|
.Tn POSIX
|
|
rules described below).
|
|
.It Ar string
|
|
.Ar string
|
|
is not empty (has non-zero length).
|
|
Note that there is the potential for problems if
|
|
.Ar string
|
|
turns out to be an operator (e.g.
|
|
.Fl r ) .
|
|
It is generally better to use a test like
|
|
.No ( Ns Nm sh )
|
|
.Bk -words
|
|
.Sm off
|
|
.Ic \&[\ X\&" Ar string Ic \&" Ic \ \&]
|
|
.Sm on
|
|
.Ek
|
|
.No or ( Ns Nm ksh )
|
|
.Bk -words
|
|
.Ic \&[[ Fl n Ar string Ic \&]]
|
|
.Ek
|
|
instead (double quotes are used in case
|
|
.Ar string
|
|
contains spaces or globbing characters).
|
|
.It Fl z Ar string
|
|
.Ar string
|
|
is empty.
|
|
.It Fl n Ar string
|
|
.Ar string
|
|
is not empty.
|
|
.It Ar string No = Ar string
|
|
Strings are equal.
|
|
.It Ar string No == Ar string
|
|
Strings are equal.
|
|
.It Ar string No \&!= Ar string
|
|
Strings are not equal.
|
|
.It Ar number Fl eq Ar number
|
|
Numbers compare equal.
|
|
.It Ar number Fl ne Ar number
|
|
Numbers compare not equal.
|
|
.It Ar number Fl ge Ar number
|
|
Numbers compare greater than or equal.
|
|
.It Ar number Fl gt Ar number
|
|
Numbers compare greater than.
|
|
.It Ar number Fl le Ar number
|
|
Numbers compare less than or equal.
|
|
.It Ar number Fl \< Ar number
|
|
Numbers compare less than.
|
|
.El
|
|
.Pp
|
|
The above basic expressions, in which unary operators have precedence over
|
|
binary operators, may be combined with the following operators (listed in
|
|
increasing order of precedence):
|
|
.Pp
|
|
.Bl -tag -width "expr -o expr" -compact
|
|
.It Ar expr Fl o Ar expr
|
|
Logical
|
|
.Tn OR .
|
|
.It Ar expr Fl a Ar expr
|
|
Logical
|
|
.Tn AND .
|
|
.It Ic \&! Ar expr
|
|
Logical
|
|
.Tn NOT .
|
|
.It Ic \&( Ar expr Ic \&)
|
|
Grouping.
|
|
.El
|
|
.Pp
|
|
On operating systems not supporting
|
|
.Pa /dev/fd/ Ns Ar n
|
|
devices (where
|
|
.Ar n
|
|
is a file descriptor number), the
|
|
.Ic test
|
|
command will attempt to fake it for all tests that operate on files (except the
|
|
.Fl e
|
|
test).
|
|
For example,
|
|
.Ic \&[ -w /dev/fd/2 \&]
|
|
tests if file descriptor 2 is writable.
|
|
.Pp
|
|
Note that some special rules are applied (courtesy of
|
|
.Tn POSIX )
|
|
if the number of
|
|
arguments to
|
|
.Ic test
|
|
or
|
|
.Ic \&[ ... \&]
|
|
is less than five; if leading
|
|
.Ql \&!
|
|
arguments can be stripped such that only one argument remains then a string
|
|
length test is performed (again, even if the argument is a unary operator); if
|
|
leading
|
|
.Ql \&!
|
|
arguments can be stripped such that three arguments remain and the second
|
|
argument is a binary operator, then the binary operation is performed (even
|
|
if the first argument is a unary operator, including an unstripped
|
|
.Ql \&! ) .
|
|
.Pp
|
|
.Sy Note:
|
|
A common mistake is to use
|
|
.Bk -words
|
|
.Ic if \&[ $foo = bar \&]
|
|
.Ek
|
|
which fails if parameter
|
|
.Ic foo
|
|
is
|
|
.Dv NULL
|
|
or unset, if it has embedded spaces (i.e.,
|
|
.Ev IFS
|
|
characters), or if it is a unary operator like
|
|
.Sq Ic \&!
|
|
or
|
|
.Sq Fl n .
|
|
Use tests like
|
|
.No ( Ns Nm sh )
|
|
.Bk -words
|
|
.Ic if \&[ \&"X$foo\&" = Xbar \&]
|
|
.Ek
|
|
.No or ( Ns Nm ksh )
|
|
.Bk -words
|
|
.Ic if \&[[ \&$foo = bar \&]]
|
|
.Ek
|
|
instead.
|
|
.It Xo Ic time Op Fl p
|
|
.Op Ar pipeline
|
|
.Xc
|
|
If a
|
|
.Ar pipeline
|
|
is given, the times used to execute the pipeline are reported.
|
|
If no pipeline
|
|
is given, then the user and system time used by the shell itself and all the
|
|
commands it has run since it was started is reported.
|
|
The times reported are the real time (elapsed time from start to finish),
|
|
the user CPU time (time spent running in user mode) and the system CPU time
|
|
(time spent running in kernel mode).
|
|
Times are reported to standard error; the format of the output is:
|
|
.Pp
|
|
.Dl " 0m0.00s real 0m0.00s user 0m0.00s system"
|
|
.Pp
|
|
If the
|
|
.Fl p
|
|
option is given the output is slightly longer:
|
|
.Bd -literal -offset indent
|
|
real 0.00
|
|
user 0.00
|
|
sys 0.00
|
|
.Ed
|
|
.Pp
|
|
It is an error to specify the
|
|
.Fl p
|
|
option unless
|
|
.Ar pipeline
|
|
is a simple command.
|
|
.Pp
|
|
Simple redirections of standard error do not effect the output of the
|
|
.Ic time
|
|
command:
|
|
.Pp
|
|
.Dl time sleep 1 2> afile
|
|
.Dl { time sleep 1; } 2> afile
|
|
.Pp
|
|
Times for the first command do not go to
|
|
.Dq afile ,
|
|
but those of the second command do.
|
|
.It Ic times
|
|
Print the accumulated user and system times used both by the shell
|
|
and by processes that the shell started which have exited.
|
|
The format of the output is:
|
|
.Bd -literal -offset indent
|
|
0m0.00s 0m0.00s
|
|
0m0.00s 0m0.00s
|
|
.Ed
|
|
.It Ic trap Op Ar handler signal ...
|
|
Sets a trap handler that is to be executed when any of the
|
|
specified signals are received.
|
|
.Ar handler
|
|
is either a
|
|
.Dv NULL
|
|
string, indicating the signals are to be ignored, a minus sign
|
|
.Pq Sq \&- ,
|
|
indicating that the default action is to be taken for the signals (see
|
|
.Xr signal 3 )
|
|
or a string containing shell commands to be evaluated and executed at the
|
|
first opportunity (i.e., when the current command completes or before
|
|
printing the next
|
|
.Ev PS1
|
|
prompt) after receipt of one of the signals.
|
|
.Ar signal
|
|
is the name of a signal (e.g.,
|
|
.Dv PIPE
|
|
or
|
|
.Dv ALRM )
|
|
or the number of the signal (see the
|
|
.Ic kill Fl l
|
|
command above).
|
|
There are two special signals:
|
|
.Dv EXIT
|
|
(also known as 0), which is executed when the shell is about to exit, and
|
|
.Dv ERR ,
|
|
which is executed after an error occurs (an error is something that would cause
|
|
the shell to exit if the
|
|
.Fl e
|
|
or
|
|
.Ic errexit
|
|
option were see \(em see the
|
|
.Ic set
|
|
command above).
|
|
.Dv EXIT
|
|
handlers are executed in the environment of the last executed command.
|
|
Note
|
|
that for non-interactive shells, the trap handler cannot be changed for signals
|
|
that were ignored when the shell started.
|
|
.Pp
|
|
With no arguments,
|
|
.Ic trap
|
|
lists, as a series of
|
|
.Ic trap
|
|
commands, the current state of the traps that have been set since the shell
|
|
started.
|
|
Note that the output of
|
|
.Ic trap
|
|
cannot be usefully piped to another process (an artifact of the fact that
|
|
traps are cleared when subprocesses are created).
|
|
.Pp
|
|
The original Korn shell's
|
|
.Dv DEBUG
|
|
trap and the handling of
|
|
.Dv ERR
|
|
and
|
|
.Dv EXIT
|
|
traps in functions are not yet implemented.
|
|
.It Ic true
|
|
A command that exits with a zero value.
|
|
.It Xo Ic typeset
|
|
.Oo Op Ic +-Ulprtux
|
|
.Op Fl L Ns Op Ar n
|
|
.Op Fl R Ns Op Ar n
|
|
.Op Fl Z Ns Op Ar n
|
|
.Op Fl i Ns Op Ar n
|
|
.No \&| Fl f Op Fl tux Oc
|
|
.Oo Ar name
|
|
.Op Ns = Ns Ar value
|
|
.Ar ... Oc
|
|
.Xc
|
|
Display or set parameter attributes.
|
|
With no
|
|
.Ar name
|
|
arguments, parameter attributes are displayed; if no options are used, the
|
|
current attributes of all parameters are printed as
|
|
.Ic typeset
|
|
commands; if an option is given (or
|
|
.Ql -
|
|
with no option letter), all parameters and their values with the specified
|
|
attributes are printed; if options are introduced with
|
|
.Ql + ,
|
|
parameter values are not printed.
|
|
.Pp
|
|
If
|
|
.Ar name
|
|
arguments are given, the attributes of the named parameters are set
|
|
.Pq Ic \&-
|
|
or cleared
|
|
.Pq Ic \&+ .
|
|
Values for parameters may optionally be specified.
|
|
If
|
|
.Ic typeset
|
|
is used inside a function, any newly created parameters are local to the
|
|
function.
|
|
.Pp
|
|
When
|
|
.Fl f
|
|
is used,
|
|
.Ic typeset
|
|
operates on the attributes of functions.
|
|
As with parameters, if no
|
|
.Ar name Ns s
|
|
are given, functions are listed with their values (i.e., definitions) unless
|
|
options are introduced with
|
|
.Ql + ,
|
|
in which case only the function names are reported.
|
|
.Bl -tag -width 3n
|
|
.It Fl L Ns Ar n
|
|
Left justify attribute.
|
|
.Ar n
|
|
specifies the field width.
|
|
If
|
|
.Ar n
|
|
is not specified, the current width of a parameter (or the width of its first
|
|
assigned value) is used.
|
|
Leading whitespace (and zeros, if used with the
|
|
.Fl Z
|
|
option) is stripped.
|
|
If necessary, values are either truncated or space padded
|
|
to fit the field width.
|
|
.It Fl R Ns Ar n
|
|
Right justify attribute.
|
|
.Ar n
|
|
specifies the field width.
|
|
If
|
|
.Ar n
|
|
is not specified, the current width of a parameter (or the width of its first
|
|
assigned value) is used.
|
|
Trailing whitespace is stripped.
|
|
If necessary, values are either stripped of leading characters or space
|
|
padded to make them fit the field width.
|
|
.It Fl Z Ns Ar n
|
|
Zero fill attribute.
|
|
If not combined with
|
|
.Fl L ,
|
|
this is the same as
|
|
.Fl R ,
|
|
except zero padding is used instead of space padding.
|
|
.It Fl i Ns Ar n
|
|
Integer attribute.
|
|
.Ar n
|
|
specifies the base to use when displaying the integer (if not specified, the
|
|
base given in the first assignment is used).
|
|
Parameters with this attribute may
|
|
be assigned values containing arithmetic expressions.
|
|
.It Fl U
|
|
Unsigned integer attribute.
|
|
Integers are printed as unsigned values (only
|
|
useful when combined with the
|
|
.Fl i
|
|
option).
|
|
This option is not in the original Korn shell.
|
|
.It Fl f
|
|
Function mode.
|
|
Display or set functions and their attributes, instead of parameters.
|
|
.It Fl l
|
|
Lower case attribute.
|
|
All upper case characters in values are converted to lower case.
|
|
(In the original Korn shell, this parameter meant
|
|
.Dq long integer
|
|
when used with the
|
|
.Fl i
|
|
option.)
|
|
.It Fl p
|
|
Print complete
|
|
.Ic typeset
|
|
commands that can be used to re-create the attributes (but not the values) of
|
|
parameters.
|
|
This is the default action (option exists for ksh93 compatibility).
|
|
.It Fl r
|
|
Read-only attribute.
|
|
Parameters with this attribute may not be assigned to or unset.
|
|
Once this attribute is set, it cannot be turned off.
|
|
.It Fl t
|
|
Tag attribute.
|
|
Has no meaning to the shell; provided for application use.
|
|
.Pp
|
|
For functions,
|
|
.Fl t
|
|
is the trace attribute.
|
|
When functions with the trace attribute are executed, the
|
|
.Ic xtrace
|
|
.Pq Fl x
|
|
shell option is temporarily turned on.
|
|
.It Fl u
|
|
Upper case attribute.
|
|
All lower case characters in values are converted to upper case.
|
|
(In the original Korn shell, this parameter meant
|
|
.Dq unsigned integer
|
|
when used with the
|
|
.Fl i
|
|
option, which meant upper case letters would never be used for bases greater
|
|
than 10.
|
|
See the
|
|
.Fl U
|
|
option.)
|
|
.Pp
|
|
For functions,
|
|
.Fl u
|
|
is the undefined attribute.
|
|
See
|
|
.Sx Functions
|
|
above for the implications of this.
|
|
.It Fl x
|
|
Export attribute.
|
|
Parameters (or functions) are placed in the environment of
|
|
any executed commands.
|
|
Exported functions are not yet implemented.
|
|
.El
|
|
.It Xo Ic ulimit Op Fl acdfHlmnpsStv
|
|
.Op Ar value
|
|
.Xc
|
|
Display or set process limits.
|
|
If no options are used, the file size limit
|
|
.Pq Fl f
|
|
is assumed.
|
|
.Ar value ,
|
|
if specified, may be either an arithmetic expression or the word
|
|
.Dq unlimited .
|
|
The limits affect the shell and any processes created by the shell after a
|
|
limit is imposed.
|
|
Note that some systems may not allow limits to be increased
|
|
once they are set.
|
|
Also note that the types of limits available are system
|
|
dependent \(em some systems have only the
|
|
.Fl f
|
|
limit.
|
|
.Bl -tag -width 5n
|
|
.It Fl a
|
|
Displays all limits; unless
|
|
.Fl H
|
|
is used, soft limits are displayed.
|
|
.It Fl H
|
|
Set the hard limit only (default is to set both hard and soft limits).
|
|
.It Fl S
|
|
Set the soft limit only (default is to set both hard and soft limits).
|
|
.It Fl c Ar n
|
|
Impose a size limit of
|
|
.Ar n
|
|
blocks on the size of core dumps.
|
|
.It Fl d Ar n
|
|
Impose a size limit of
|
|
.Ar n
|
|
kibibytes on the size of the data area.
|
|
.It Fl f Ar n
|
|
Impose a size limit of
|
|
.Ar n
|
|
blocks on files written by the shell and its child processes (files of any
|
|
size may be read).
|
|
.It Fl l Ar n
|
|
Impose a limit of
|
|
.Ar n
|
|
kibibytes on the amount of locked (wired) physical memory.
|
|
.It Fl m Ar n
|
|
Impose a limit of
|
|
.Ar n
|
|
kibibytes on the amount of physical memory used.
|
|
.It Fl n Ar n
|
|
Impose a limit of
|
|
.Ar n
|
|
file descriptors that can be open at once.
|
|
.It Fl p Ar n
|
|
Impose a limit of
|
|
.Ar n
|
|
processes that can be run by the user at any one time.
|
|
.It Fl s Ar n
|
|
Impose a size limit of
|
|
.Ar n
|
|
kibibytes on the size of the stack area.
|
|
.It Fl t Ar n
|
|
Impose a time limit of
|
|
.Ar n
|
|
.Tn CPU
|
|
seconds to be used by each process.
|
|
.It Fl T Ar n
|
|
Impose a real time limit of
|
|
.Ar n
|
|
.Tn human
|
|
seconds to be used by each process.
|
|
.It Fl v Ar n
|
|
Impose a limit of
|
|
.Ar n
|
|
kibibytes on the amount of virtual memory used.
|
|
.El
|
|
.Pp
|
|
As far as
|
|
.Ic ulimit
|
|
is concerned, a block is 512 bytes.
|
|
.It Xo Ic umask Op Fl S
|
|
.Op Ar mask
|
|
.Xc
|
|
Display or set the file permission creation mask or umask (see
|
|
.Xr umask 2 ) .
|
|
If the
|
|
.Fl S
|
|
option is used, the mask displayed or set is symbolic; otherwise, it is an
|
|
octal number.
|
|
.Pp
|
|
Symbolic masks are like those used by
|
|
.Xr chmod 1 .
|
|
When used, they describe what permissions may be made available (as opposed to
|
|
octal masks in which a set bit means the corresponding bit is to be cleared).
|
|
For example,
|
|
.Dq ug=rwx,o=
|
|
sets the mask so files will not be readable, writable or executable by
|
|
.Dq others
|
|
and is equivalent (on most systems) to the octal mask
|
|
.Dq 007 .
|
|
.It Xo Ic unalias Op Fl adt
|
|
.Op Ar name1 ...
|
|
.Xc
|
|
The aliases for the given names are removed.
|
|
If the
|
|
.Fl a
|
|
option is used, all aliases are removed.
|
|
If the
|
|
.Fl t
|
|
or
|
|
.Fl d
|
|
options are used, the indicated operations are carried out on tracked or
|
|
directory aliases, respectively.
|
|
.It Xo Ic unset Op Fl fv
|
|
.Ar parameter ...
|
|
.Xc
|
|
Unset the named parameters
|
|
.Po
|
|
.Fl v ,
|
|
the default
|
|
.Pc
|
|
or functions
|
|
.Pq Fl f .
|
|
The exit status is non-zero if any of the parameters were already unset, zero
|
|
otherwise.
|
|
.It Ic wait Op Ar job ...
|
|
Wait for the specified job(s) to finish.
|
|
The exit status of
|
|
.Ic wait
|
|
is that of the last specified job; if the last job is killed by a signal, the
|
|
exit status is 128 + the number of the signal (see
|
|
.Ic kill -l Ar exit-status
|
|
above); if the last specified job can't be found (because it never existed or
|
|
had already finished), the exit status of
|
|
.Ic wait
|
|
is 127.
|
|
See
|
|
.Sx Job control
|
|
below for the format of
|
|
.Ar job .
|
|
.Ic wait
|
|
will return if a signal for which a trap has been set is received or if a
|
|
.Dv SIGHUP ,
|
|
.Dv SIGINT
|
|
or
|
|
.Dv SIGQUIT
|
|
signal is received.
|
|
.Pp
|
|
If no jobs are specified,
|
|
.Ic wait
|
|
waits for all currently running jobs (if any) to finish and exits with a zero
|
|
status.
|
|
If job monitoring is enabled, the completion status of jobs is printed
|
|
(this is not the case when jobs are explicitly specified).
|
|
.It Xo Ic whence Op Fl pv
|
|
.Op Ar name ...
|
|
.Xc
|
|
For each
|
|
.Ar name ,
|
|
the type of command is listed (reserved word, built-in, alias,
|
|
function, tracked alias or executable).
|
|
If the
|
|
.Fl p
|
|
option is used, a path search is performed even if
|
|
.Ar name
|
|
is a reserved word, alias, etc.
|
|
Without the
|
|
.Fl v
|
|
option,
|
|
.Ic whence
|
|
is similar to
|
|
.Ic command Fl v
|
|
except that
|
|
.Ic whence
|
|
will find reserved words and won't print aliases as alias commands.
|
|
With the
|
|
.Fl v
|
|
option,
|
|
.Ic whence
|
|
is the same as
|
|
.Ic command Fl V .
|
|
Note that for
|
|
.Ic whence ,
|
|
the
|
|
.Fl p
|
|
option does not affect the search path used, as it does for
|
|
.Ic command .
|
|
If the type of one or more of the names could not be determined, the exit
|
|
status is non-zero.
|
|
.El
|
|
.Ss Job control
|
|
Job control refers to the shell's ability to monitor and control jobs, which
|
|
are processes or groups of processes created for commands or pipelines.
|
|
At a minimum, the shell keeps track of the status of the background (i.e.,
|
|
asynchronous) jobs that currently exist; this information can be displayed
|
|
using the
|
|
.Ic jobs
|
|
commands.
|
|
If job control is fully enabled (using
|
|
.Ic set Fl m
|
|
or
|
|
.Ic set Fl o Ic monitor ) ,
|
|
as it is for interactive shells, the processes of a job are placed in their
|
|
own process group.
|
|
Foreground jobs can be stopped by typing the suspend
|
|
character from the terminal (normally ^Z), jobs can be restarted in either the
|
|
foreground or background using the
|
|
.Ic fg
|
|
and
|
|
.Ic bg
|
|
commands, and the state of the terminal is saved or restored when a foreground
|
|
job is stopped or restarted, respectively.
|
|
.Pp
|
|
Note that only commands that create processes (e.g., asynchronous commands,
|
|
subshell commands and non-built-in, non-function commands) can be stopped;
|
|
commands like
|
|
.Ic read
|
|
cannot be.
|
|
.Pp
|
|
When a job is created, it is assigned a job number.
|
|
For interactive shells, this number is printed inside
|
|
.Dq \&[..\&] ,
|
|
followed by the process IDs of the processes in the job when an asynchronous
|
|
command is run.
|
|
A job may be referred to in the
|
|
.Ic bg ,
|
|
.Ic fg ,
|
|
.Ic jobs ,
|
|
.Ic kill
|
|
and
|
|
.Ic wait
|
|
commands either by the process ID of the last process in the command pipeline
|
|
(as stored in the
|
|
.Ic $\&!
|
|
parameter) or by prefixing the job number with a percent sign
|
|
.Pq Sq % .
|
|
Other percent sequences can also be used to refer to jobs:
|
|
.Bl -tag -width 10n
|
|
.It Ic %\&+
|
|
The most recently stopped job or, if there are no stopped jobs, the oldest
|
|
running job.
|
|
.It Ic %% , %
|
|
Same as
|
|
.Ic %\&+ .
|
|
.It Ic %\&-
|
|
The job that would be the
|
|
.Ic %\&+
|
|
job if the latter did not exist.
|
|
.It Ic % Ns Ar n
|
|
The job with job number
|
|
.Ar n .
|
|
.It Ic %\&? Ns Ar string
|
|
The job containing the string
|
|
.Ar string
|
|
(an error occurs if multiple jobs are matched).
|
|
.It Ic % Ns Ar string
|
|
The job starting with string
|
|
.Ar string
|
|
(an error occurs if multiple jobs are matched).
|
|
.El
|
|
.Pp
|
|
When a job changes state (e.g., a background job finishes or foreground job is
|
|
stopped), the shell prints the following status information:
|
|
.Bd -unfilled -offset indent
|
|
.Ic \&[ Ar number Ic \&] Ar flag status command
|
|
.Ed
|
|
.Pp
|
|
where
|
|
.Bl -tag -width "status"
|
|
.It Ar number
|
|
is the job number of the job.
|
|
.It Ar flag
|
|
is the
|
|
.Ql +
|
|
or
|
|
.Ql -
|
|
character if the job is the
|
|
.Ic %\&+ or
|
|
.Ic %\&-
|
|
job, respectively, or space if it is neither.
|
|
.It Ar status
|
|
indicates the current state of the job and can be:
|
|
.Bl -tag -width "Running"
|
|
.It Cm Running
|
|
The job has neither stopped nor exited (note that running does not necessarily
|
|
mean consuming
|
|
.Tn CPU
|
|
time \(em the process could be blocked waiting for some
|
|
event).
|
|
.It Cm Done Op Ar number
|
|
The job exited.
|
|
.Ar number
|
|
is the exit status of the job, which is omitted if the status is zero.
|
|
.It Cm Stopped Op Ar signal
|
|
The job was stopped by the indicated
|
|
.Ar signal
|
|
(if no signal is given, the job was stopped by
|
|
.Dv SIGTSTP ) .
|
|
.It Ar signal-description Op Dq core dumped
|
|
The job was killed by a signal (e.g., memory fault, hangup, etc.; use
|
|
.Ic kill -l
|
|
for a list of signal descriptions).
|
|
The
|
|
.Dq core dumped
|
|
message indicates the process created a core file.
|
|
.El
|
|
.It Ar command
|
|
is the command that created the process.
|
|
If there are multiple processes in
|
|
the job, each process will have a line showing its
|
|
.Ar command
|
|
and possibly its
|
|
.Ar status ,
|
|
if it is different from the status of the previous process.
|
|
.El
|
|
.Pp
|
|
When an attempt is made to exit the shell while there are jobs in the stopped
|
|
state, the shell warns the user that there are stopped jobs and does not exit.
|
|
If another attempt is immediately made to exit the shell, the stopped jobs are
|
|
sent a
|
|
.Dv SIGHUP
|
|
signal and the shell exits.
|
|
Similarly, if the
|
|
.Ic nohup
|
|
option is not set and there are running jobs when an attempt is made to exit
|
|
a login shell, the shell warns the user and does not exit.
|
|
If another attempt
|
|
is immediately made to exit the shell, the running jobs are sent a
|
|
.Dv SIGHUP
|
|
signal and the shell exits.
|
|
.Ss Interactive input line editing
|
|
The shell supports three modes of reading command lines from a
|
|
.Xr tty 4
|
|
in an interactive session, which is controlled by the
|
|
.Ic emacs ,
|
|
.Ic gmacs
|
|
and
|
|
.Ic vi
|
|
options (at most one of these can be set at once).
|
|
If none of these options are enabled, the shell simply
|
|
reads lines using the normal
|
|
.Xr tty 4
|
|
driver.
|
|
If the
|
|
.Ic emacs
|
|
or
|
|
.Ic gmacs
|
|
option is set, the shell allows emacs-like editing of the command; similarly,
|
|
if the
|
|
.Ic vi
|
|
option is set, the shell allows vi-like editing of the command.
|
|
These modes are described in detail in the following sections.
|
|
.Pp
|
|
In these editing modes, if a line is longer than the screen width (see
|
|
.Ev COLUMNS
|
|
parameter),
|
|
a
|
|
.Ql > ,
|
|
.Ql +
|
|
or
|
|
.Ql <
|
|
character is displayed in the last column indicating that there are more
|
|
characters after, before and after, or before the current position,
|
|
respectively.
|
|
The line is scrolled horizontally as necessary.
|
|
.Ss Emacs editing mode
|
|
When the
|
|
.Ic emacs
|
|
option is set, interactive input line editing is enabled.
|
|
Warning: This mode is
|
|
slightly different from the emacs mode in the original Korn shell.
|
|
By default, the eight bit is used as Meta, but this can be turned
|
|
off by entering
|
|
.Ic set +o emacs-usemeta ,
|
|
contained in the default
|
|
.Mx 6
|
|
.Pa /etc/profile .
|
|
.Pp
|
|
In the emacs mode, various editing commands
|
|
(typically bound to one or more control characters) cause immediate actions
|
|
without waiting for a newline.
|
|
Several editing commands are bound to particular
|
|
control characters when the shell is invoked; these bindings can be changed
|
|
using the
|
|
.Ic bind
|
|
command.
|
|
.Pp
|
|
The following is a list of available editing commands.
|
|
Each description starts with the name of the command, an
|
|
.Ar n
|
|
(if the command can be prefixed with a count) and any keys the command is
|
|
bound to by default (written using caret notation, i.e.,
|
|
.Tn "ASCII ESC"
|
|
character is
|
|
written as ^[).
|
|
A count prefix for a command is entered using the sequence
|
|
.Ic ^\&[ Ns Ar n ,
|
|
where
|
|
.Ar n
|
|
is a sequence of 1 or more digits; unless otherwise specified, if a count is
|
|
omitted, it defaults to 1.
|
|
Note that editing command names are used only with the
|
|
.Ic bind
|
|
command.
|
|
Furthermore, many editing commands are useful only on terminals with
|
|
a visible cursor.
|
|
The default bindings were chosen to resemble corresponding
|
|
Emacs key bindings.
|
|
The users'
|
|
.Xr tty 4
|
|
characters (e.g.,
|
|
.Dv ERASE )
|
|
are bound to
|
|
reasonable substitutes and override the default bindings.
|
|
.Bl -tag -width Ds
|
|
.It Ic abort ^G
|
|
Useful as a response to a request for a
|
|
.Ic search-history
|
|
pattern in order to abort the search.
|
|
.It Ic auto-insert Ar n
|
|
Simply causes the character to appear as literal input.
|
|
Most ordinary characters are bound to this.
|
|
.It Ic backward-char Ar n Ic ^B
|
|
Moves the cursor backward
|
|
.Ar n
|
|
characters.
|
|
.It Ic backward-word Ar n Ic ^[B
|
|
Moves the cursor backward to the beginning of the word; words consist of
|
|
alphanumerics, underscore
|
|
.Pq Sq _
|
|
and dollar sign
|
|
.Pq Sq \&$
|
|
characters.
|
|
.It Ic beginning-of-history ^[<
|
|
Moves to the beginning of the history.
|
|
.It Ic beginning-of-line ^A
|
|
Moves the cursor to the beginning of the edited input line.
|
|
.It Ic capitalize-word Ar n Ic ^[c , ^[C
|
|
Uppercase the first character in the next
|
|
.Ar n
|
|
words, leaving the cursor past the end of the last word.
|
|
.Pp
|
|
If the current line does not begin with a comment character, one is added at
|
|
the beginning of the line and the line is entered (as if return had been
|
|
pressed); otherwise, the existing comment characters are removed and the cursor
|
|
is placed at the beginning of the line.
|
|
.It Ic complete ^[^[
|
|
.It Ic complete ^I
|
|
Automatically completes as much as is unique of the command name or the file
|
|
name containing the cursor.
|
|
If the entire remaining command or file name is
|
|
unique, a space is printed after its completion, unless it is a directory name
|
|
in which case
|
|
.Ql /
|
|
is appended.
|
|
If there is no command or file name with the current partial word
|
|
as its prefix, a bell character is output (usually causing a beep to be
|
|
sounded).
|
|
Currently being considered a bug,
|
|
if the file name contains \fB[\fR or \fB]\fR, it cannot be completed, even if
|
|
the character is escaped, in \fBemacs\fR mode.
|
|
This surprisingly works in \fBvi\fR mode; please submit a fix.
|
|
.It Ic complete-command ^X^[
|
|
Automatically completes as much as is unique of the command name having the
|
|
partial word up to the cursor as its prefix, as in the
|
|
.Ic complete
|
|
command above.
|
|
.It Ic complete-file ^[^X
|
|
Automatically completes as much as is unique of the file name having the
|
|
partial word up to the cursor as its prefix, as in the
|
|
.Ic complete
|
|
command described above.
|
|
.It Ic complete-list ^[=
|
|
List the possible completions for the current word.
|
|
.It Xo Ic delete-char-backward Ar n Ic ERASE ,
|
|
.Ic ^? , ^H
|
|
.Xc
|
|
Deletes
|
|
.Ar n
|
|
characters before the cursor.
|
|
.It Ic delete-char-forward Ar n
|
|
Deletes
|
|
.Ar n
|
|
characters after the cursor.
|
|
.It Xo Ic delete-word-backward Ar n Ic ^[ERASE ,
|
|
.Ic ^[^? , ^[^H , ^[h
|
|
.Xc
|
|
Deletes
|
|
.Ar n
|
|
words before the cursor.
|
|
.It Ic delete-word-forward Ar n Ic ^[d
|
|
Deletes characters after the cursor up to the end of
|
|
.Ar n
|
|
words.
|
|
.It Ic down-history Ar n Ic ^N
|
|
Scrolls the history buffer forward
|
|
.Ar n
|
|
lines (later).
|
|
Each input line originally starts just after the last entry
|
|
in the history buffer, so
|
|
.Ic down-history
|
|
is not useful until either
|
|
.Ic search-history
|
|
or
|
|
.Ic up-history
|
|
has been performed.
|
|
.It Ic downcase-word Ar n Ic ^[L , ^[l
|
|
Lowercases the next
|
|
.Ar n
|
|
words.
|
|
.It Ic end-of-history ^[>
|
|
Moves to the end of the history.
|
|
.It Ic end-of-line ^E
|
|
Moves the cursor to the end of the input line.
|
|
.It Ic eot ^_
|
|
Acts as an end-of-file; this is useful because edit-mode input disables
|
|
normal terminal input canonicalization.
|
|
.It Ic eot-or-delete Ar n Ic ^D
|
|
Acts as
|
|
.Ic eot
|
|
if alone on a line; otherwise acts as
|
|
.Ic delete-char-forward .
|
|
.It Ic error
|
|
Error (ring the bell).
|
|
.It Ic exchange-point-and-mark ^X^X
|
|
Places the cursor where the mark is and sets the mark to where the cursor was.
|
|
.It Ic expand-file ^[\&*
|
|
Appends a
|
|
.Ql *
|
|
to the current word and replaces the word with the result of performing file
|
|
globbing on the word.
|
|
If no files match the pattern, the bell is rung.
|
|
.It Ic forward-char Ar n Ic ^F
|
|
Moves the cursor forward
|
|
.Ar n
|
|
characters.
|
|
.It Ic forward-word Ar n Ic ^[f
|
|
Moves the cursor forward to the end of the
|
|
.Ar n Ns th
|
|
word.
|
|
.It Ic goto-history Ar n Ic ^[g
|
|
Goes to history number
|
|
.Ar n .
|
|
.It Ic kill-line KILL
|
|
Deletes the entire input line.
|
|
.It Ic kill-region ^W
|
|
Deletes the input between the cursor and the mark.
|
|
.It Ic kill-to-eol Ar n Ic ^K
|
|
Deletes the input from the cursor to the end of the line if
|
|
.Ar n
|
|
is not specified; otherwise deletes characters between the cursor and column
|
|
.Ar n .
|
|
.It Ic list ^[?
|
|
Prints a sorted, columnated list of command named or file names (if any) that
|
|
can complete the partial word containing the cursor.
|
|
Directory names have
|
|
.Ql /
|
|
appended to them.
|
|
.It Ic list-command ^X?
|
|
Prints a sorted, columnated list of command names (if any) that can complete
|
|
the partial word containing the cursor.
|
|
.It Ic list-file ^X^Y
|
|
Prints a sorted, columnated list of file names (if any) that can complete the
|
|
partial word containing the cursor.
|
|
File type indicators are appended as described under
|
|
.Ic list
|
|
above.
|
|
.It Ic newline ^J , ^M
|
|
Causes the current input line to be processed by the shell.
|
|
The current cursor position may be anywhere on the line.
|
|
.It Ic newline-and-next ^O
|
|
Causes the current input line to be processed by the shell, and the next line
|
|
from history becomes the current line.
|
|
This is only useful after an
|
|
.Ic up-history
|
|
or
|
|
.Ic search-history .
|
|
.It Ic no-op QUIT
|
|
This does nothing.
|
|
.It Ic prefix-1 ^[
|
|
Introduces a 2-character command sequence.
|
|
.It Ic prefix-2 ^X
|
|
.It Ic prefix-2 ^[[
|
|
Introduces a 2-character command sequence.
|
|
.It Ic prev-hist-word Ar n Ic ^[\&. , ^{_
|
|
The last
|
|
.Pq Ar n Ns th
|
|
word of the previous command is inserted at the cursor.
|
|
.It Ic quote ^^
|
|
The following character is taken literally rather than as an editing command.
|
|
.It Ic redraw ^L
|
|
Reprints the prompt string and the current input line.
|
|
.It Ic search-character-backward Ar n Ic ^[^]
|
|
Search backward in the current line for the
|
|
.Ar n Ns th
|
|
occurrence of the next character typed.
|
|
.It Ic search-character-forward Ar n Ic ^]
|
|
Search forward in the current line for the
|
|
.Ar n Ns th
|
|
occurrence of the next character typed.
|
|
.It Ic search-history ^R
|
|
Enter incremental search mode.
|
|
The internal history list is searched
|
|
backwards for commands matching the input.
|
|
An initial
|
|
.Ql ^
|
|
in the search string anchors the search.
|
|
The abort key will leave search mode.
|
|
Other commands will be executed after leaving search mode.
|
|
Successive
|
|
.Ic search-history
|
|
commands continue searching backward to the next previous occurrence of the
|
|
pattern.
|
|
The history buffer retains only a finite number of lines; the oldest
|
|
are discarded as necessary.
|
|
.It Ic set-mark-command ^[ Ns <space>
|
|
Set the mark at the cursor position.
|
|
.It Ic stuff
|
|
On systems supporting it, pushes the bound character back onto the terminal
|
|
input where it may receive special processing by the terminal handler.
|
|
This is useful for the BRL ^T mini-systat feature, for example.
|
|
.It Ic stuff-reset
|
|
Acts like
|
|
.Ic stuff ,
|
|
then aborts input the same as an interrupt.
|
|
.It Ic transpose-chars ^T
|
|
If at the end of line or if the
|
|
.Ic gmacs
|
|
option is set, this exchanges the two previous characters; otherwise, it
|
|
exchanges the previous and current characters and moves the cursor one
|
|
character to the right.
|
|
.It Ic up-history Ar n Ic ^P
|
|
Scrolls the history buffer backward
|
|
.Ar n
|
|
lines (earlier).
|
|
.It Ic upcase-word Ar n Ic ^[U , ^[u
|
|
Uppercase the next
|
|
.Ar n
|
|
words.
|
|
.It Ic version ^V
|
|
Display the version of
|
|
.Nm mksh .
|
|
The current edit buffer is restored as soon as any
|
|
key is pressed (the key is then processed, unless it is a space).
|
|
.It Ic yank ^Y
|
|
Inserts the most recently killed text string at the current cursor position.
|
|
.It Ic yank-pop ^[y
|
|
Immediately after a
|
|
.Ic yank ,
|
|
replaces the inserted text string with the next previously killed text string.
|
|
.El
|
|
.Ss Vi editing mode
|
|
The vi command-line editor in
|
|
.Nm
|
|
has basically the same commands as the vi editor (see
|
|
.Xr vi 1 ) ,
|
|
with the following exceptions:
|
|
.Bl -bullet
|
|
.It
|
|
You start out in insert mode.
|
|
.It
|
|
There are file name and command completion commands
|
|
.Po
|
|
.Ic = , \e , \&* , ^X ,
|
|
.Ic ^E , ^F
|
|
and, optionally,
|
|
.Ic <tab>
|
|
.Pc .
|
|
.It
|
|
The
|
|
.Ic _
|
|
command is different (in
|
|
.Nm
|
|
it is the last argument command, in vi it goes to
|
|
the start of the current line).
|
|
.It
|
|
The
|
|
.Ic /
|
|
and
|
|
.Ic G
|
|
commands move in the opposite direction as the
|
|
.Ic j
|
|
command.
|
|
.It
|
|
Commands which don't make sense in a single line editor are not available
|
|
(e.g., screen movement commands,
|
|
.Xr ex 1 Ns -style
|
|
colon
|
|
.Pq Ic \&:
|
|
commands, etc.).
|
|
.El
|
|
.Pp
|
|
Note that the ^X stands for control-X; also <esc>, <space> and <tab> are used
|
|
for escape, space and tab, respectively (no kidding).
|
|
.Pp
|
|
Like vi, there are two modes \(em
|
|
.Dq insert
|
|
mode and
|
|
.Dq command
|
|
mode.
|
|
In insert mode, most characters are simply put in the buffer at the
|
|
current cursor position as they are typed; however, some characters are
|
|
treated specially.
|
|
In particular, the following characters are taken from current
|
|
.Xr tty 4
|
|
settings (see
|
|
.Xr tty 1 )
|
|
and have their usual meaning (normal values are in parentheses): kill (^U),
|
|
erase (^?), werase (^W), eof (^D), intr (^C) and quit (^\e).
|
|
In addition to
|
|
the above, the following characters are also treated specially in insert mode:
|
|
.Bl -tag -width 10n
|
|
.It Ic ^H
|
|
Erases previous character.
|
|
.It Ic ^V
|
|
Literal next.
|
|
The next character typed is not treated specially (can be used
|
|
to insert the characters being described here).
|
|
.It Ic ^J ^M
|
|
End of line.
|
|
The current line is read, parsed and executed by the shell.
|
|
.It Ic <esc>
|
|
Puts the editor in command mode (see below).
|
|
.It Ic ^E
|
|
Command and file name enumeration (see below).
|
|
.It Ic ^F
|
|
Command and file name completion (see below).
|
|
If used twice in a row, the
|
|
list of possible completions is displayed; if used a third time, the completion
|
|
is undone.
|
|
.It Ic ^X
|
|
Command and file name expansion (see below).
|
|
.It Ic <tab>
|
|
Optional file name and command completion (see
|
|
.Ic ^F
|
|
above), enabled with
|
|
.Ic set Fl o Ic vi-tabcomplete .
|
|
.El
|
|
.Pp
|
|
In command mode, each character is interpreted as a command.
|
|
Characters that
|
|
don't correspond to commands, are illegal combinations of commands or are
|
|
commands that can't be carried out all cause beeps.
|
|
In the following command descriptions, an
|
|
.Ar n
|
|
indicates the command may be prefixed by a number (e.g.,
|
|
.Ic 10l
|
|
moves right 10 characters); if no number prefix is used,
|
|
.Ar n
|
|
is assumed to be 1 unless otherwise specified.
|
|
The term
|
|
.Dq current position
|
|
refers to the position between the cursor and the character preceding the
|
|
cursor.
|
|
A
|
|
.Dq word
|
|
is a sequence of letters, digits and underscore characters or a sequence of
|
|
non-letter, non-digit, non-underscore, non-whitespace characters (e.g.,
|
|
.Dq ab2\&*\&&^
|
|
contains two words) and a
|
|
.Dq big-word
|
|
is a sequence of non-whitespace characters.
|
|
.Pp
|
|
Special
|
|
.Nm
|
|
vi commands
|
|
.Pp
|
|
The following commands are not in, or are different from, the normal vi file
|
|
editor:
|
|
.Bl -tag -width 10n
|
|
.It Ar n Ns _
|
|
Insert a space followed by the
|
|
.Ar n Ns th
|
|
big-word from the last command in the history at the current position and enter
|
|
insert mode; if
|
|
.Ar n
|
|
is not specified, the last word is inserted.
|
|
.It Ic \&#
|
|
Insert the comment character
|
|
.Pq Sq \&#
|
|
at the start of the current line and return the line to the shell (equivalent
|
|
to
|
|
.Ic \&I\&#^J ) .
|
|
.It Ar n Ns Ic g
|
|
Like
|
|
.Ic G ,
|
|
except if
|
|
.Ar n
|
|
is not specified, it goes to the most recent remembered line.
|
|
.It Ar n Ns Ic v
|
|
Edit line
|
|
.Ar n
|
|
using the vi editor; if
|
|
.Ar n
|
|
is not specified, the current line is edited.
|
|
The actual command executed is
|
|
.Ic fc Fl e Ic ${VISUAL:-${EDITOR:-vi}} Ar n .
|
|
.It Ic \&* No and Ic ^X
|
|
Command or file name expansion is applied to the current big-word (with an
|
|
appended
|
|
.Ql * ,
|
|
if the word contains no file globbing characters) \(em the big-word is replaced
|
|
with the resulting words.
|
|
If the current big-word is the first on the line (or
|
|
follows one of the characters
|
|
.Ql \&; ,
|
|
.Ql | ,
|
|
.Ql & ,
|
|
.Ql (
|
|
or
|
|
.Ql \&) )
|
|
and does not contain a slash
|
|
.Pq Sq /
|
|
then the command expansion is done; otherwise file name expansion is done.
|
|
Command expansion will match the big-word against all aliases, functions and
|
|
built-in commands as well as any executable files found by searching the
|
|
directories in the
|
|
.Ev PATH
|
|
parameter.
|
|
File name expansion matches the big-word against the files in the
|
|
current directory.
|
|
After expansion, the cursor is placed just past the last
|
|
word and the editor is in insert mode.
|
|
.It Xo
|
|
.Ar n Ns Ic \e Ns ,
|
|
.Ar n Ns Ic ^F ,
|
|
.Ar n Ns Ic <tab> ,
|
|
.No and
|
|
.Ar n Ns Ic <esc>
|
|
.Xc
|
|
Command/file name completion.
|
|
Replace the current big-word with the
|
|
longest unique match obtained after performing command and file name expansion.
|
|
.Ic <tab>
|
|
is only recognized if the
|
|
.Ic vi-tabcomplete
|
|
option is set, while
|
|
.Ic <esc>
|
|
is only recognized if the
|
|
.Ic vi-esccomplete
|
|
option is set (see
|
|
.Ic set Fl o ) .
|
|
If
|
|
.Ar n
|
|
is specified, the
|
|
.Ar n Ns th
|
|
possible completion is selected (as reported by the command/file name
|
|
enumeration command).
|
|
.It Ic \&= No and Ic ^E
|
|
Command/file name enumeration.
|
|
List all the commands or files that match the current big-word.
|
|
.It Ic ^V
|
|
Display the version of
|
|
.Nm
|
|
until another key is pressed (this key is ignored).
|
|
.It Ic @ Ns Ar c
|
|
Macro expansion.
|
|
Execute the commands found in the alias
|
|
.Ar c .
|
|
.El
|
|
.Pp
|
|
Intra-line movement commands:
|
|
.Bl -tag -width Ds
|
|
.It Xo Ar n Ns Ic h No and
|
|
.Ar n Ns Ic ^H
|
|
.Xc
|
|
Move left
|
|
.Ar n
|
|
characters.
|
|
.It Xo Ar n Ns Ic l No and
|
|
.Ar n Ns Ic <space>
|
|
.Xc
|
|
Move right
|
|
.Ar n
|
|
characters.
|
|
.It Ic \&0
|
|
Move to column 0.
|
|
.It Ic ^
|
|
Move to the first non-whitespace character.
|
|
.It Ar n Ns Ic \&|
|
|
Move to column
|
|
.Ar n .
|
|
.It Ic $
|
|
Move to the last character.
|
|
.It Ar n Ns Ic b
|
|
Move back
|
|
.Ar n
|
|
words.
|
|
.It Ar n Ns Ic B
|
|
Move back
|
|
.Ar n
|
|
big-words.
|
|
.It Ar n Ns Ic e
|
|
Move forward to the end of the word,
|
|
.Ar n
|
|
times.
|
|
.It Ar n Ns Ic E
|
|
Move forward to the end of the big-word,
|
|
.Ar n
|
|
times.
|
|
.It Ar n Ns Ic w
|
|
Move forward
|
|
.Ar n
|
|
words.
|
|
.It Ar n Ns Ic W
|
|
Move forward
|
|
.Ar n
|
|
big-words.
|
|
.It Ic %
|
|
Find match.
|
|
The editor looks forward for the nearest parenthesis, bracket or
|
|
brace and then moves the cursor to the matching parenthesis, bracket or brace.
|
|
.It Ar n Ns Ic f Ns Ar c
|
|
Move forward to the
|
|
.Ar n Ns th
|
|
occurrence of the character
|
|
.Ar c .
|
|
.It Ar n Ns Ic F Ns Ar c
|
|
Move backward to the
|
|
.Ar n Ns th
|
|
occurrence of the character
|
|
.Ar c .
|
|
.It Ar n Ns Ic t Ns Ar c
|
|
Move forward to just before the
|
|
.Ar n Ns th
|
|
occurrence of the character
|
|
.Ar c .
|
|
.It Ar n Ns Ic T Ns Ar c
|
|
Move backward to just before the
|
|
.Ar n Ns th
|
|
occurrence of the character
|
|
.Ar c .
|
|
.It Ar n Ns Ic \&;
|
|
Repeats the last
|
|
.Ic f , F , t
|
|
or
|
|
.Ic T
|
|
command.
|
|
.It Ar n Ns Ic \&,
|
|
Repeats the last
|
|
.Ic f , F , t
|
|
or
|
|
.Ic T
|
|
command, but moves in the opposite direction.
|
|
.El
|
|
.Pp
|
|
Inter-line movement commands:
|
|
.Bl -tag -width Ds
|
|
.It Xo
|
|
.Ar n Ns Ic j ,
|
|
.Ar n Ns Ic +
|
|
.No and
|
|
.Ar n Ns Ic ^N
|
|
.Xc
|
|
Move to the
|
|
.Ar n Ns th
|
|
next line in the history.
|
|
.It Xo
|
|
.Ar n Ns Ic k ,
|
|
.Ar n Ns Ic -
|
|
.No and
|
|
.Ar n Ns Ic ^P
|
|
.Xc
|
|
Move to the
|
|
.Ar n Ns th
|
|
previous line in the history.
|
|
.It Ar n Ns Ic G
|
|
Move to line
|
|
.Ar n
|
|
in the history; if
|
|
.Ar n
|
|
is not specified, the number of the first remembered line is used.
|
|
.It Ar n Ns Ic g
|
|
Like
|
|
.Ic G ,
|
|
except if
|
|
.Ar n
|
|
is not specified, it goes to the most recent remembered line.
|
|
.It Ar n Ns Ic / Ns Ar string
|
|
Search backward through the history for the
|
|
.Ar n Ns th
|
|
line containing
|
|
.Ar string ;
|
|
if
|
|
.Ar string
|
|
starts with
|
|
.Ql ^ ,
|
|
the remainder of the string must appear at the start of the history line for
|
|
it to match.
|
|
.It Ar n Ns Ic \&? Ns Ar string
|
|
Same as
|
|
.Ic / ,
|
|
except it searches forward through the history.
|
|
.It Ar n Ns Ic n
|
|
Search for the
|
|
.Ar n Ns th
|
|
occurrence of the last search string; the directory of the search is the same
|
|
as the last search.
|
|
.It Ar n Ns Ic N
|
|
Search for the
|
|
.Ar n Ns th
|
|
occurrence of the last search string; the directory of the search is the
|
|
opposite of the last search.
|
|
.El
|
|
.Pp
|
|
Edit commands
|
|
.Bl -tag -width Ds
|
|
.It Ar n Ns Ic a
|
|
Append text
|
|
.Ar n
|
|
times; goes into insert mode just after the current position.
|
|
The append is
|
|
only replicated if command mode is re-entered (i.e., <esc> is used).
|
|
.It Ar n Ns Ic A
|
|
Same as
|
|
.Ic a ,
|
|
except it appends at the end of the line.
|
|
.It Ar n Ns Ic i
|
|
Insert text
|
|
.Ar n
|
|
times; goes into insert mode at the current position.
|
|
The insertion is only
|
|
replicated if command mode is re-entered (i.e., <esc> is used).
|
|
.It Ar n Ns Ic I
|
|
Same as
|
|
.Ic i ,
|
|
except the insertion is done just before the first non-blank character.
|
|
.It Ar n Ns Ic s
|
|
Substitute the next
|
|
.Ar n
|
|
characters (i.e., delete the characters and go into insert mode).
|
|
.It Ic S
|
|
Substitute whole line.
|
|
All characters from the first non-blank character to the
|
|
end of the line are deleted and insert mode is entered.
|
|
.It Ar n Ns Ic c Ns Ar move-cmd
|
|
Change from the current position to the position resulting from
|
|
.Ar n move-cmd Ns s
|
|
(i.e., delete the indicated region and go into insert mode); if
|
|
.Ar move-cmd
|
|
is
|
|
.Ic c ,
|
|
the line starting from the first non-blank character is changed.
|
|
.It Ic C
|
|
Change from the current position to the end of the line (i.e., delete to the
|
|
end of the line and go into insert mode).
|
|
.It Ar n Ns Ic x
|
|
Delete the next
|
|
.Ar n
|
|
characters.
|
|
.It Ar n Ns Ic X
|
|
Delete the previous
|
|
.Ar n
|
|
characters.
|
|
.It Ic D
|
|
Delete to the end of the line.
|
|
.It Ar n Ns Ic d Ns Ar move-cmd
|
|
Delete from the current position to the position resulting from
|
|
.Ar n move-cmd Ns s ;
|
|
.Ar move-cmd
|
|
is a movement command (see above) or
|
|
.Ic d ,
|
|
in which case the current line is deleted.
|
|
.It Ar n Ns Ic r Ns Ar c
|
|
Replace the next
|
|
.Ar n
|
|
characters with the character
|
|
.Ar c .
|
|
.It Ar n Ns Ic R
|
|
Replace.
|
|
Enter insert mode but overwrite existing characters instead of
|
|
inserting before existing characters.
|
|
The replacement is repeated
|
|
.Ar n
|
|
times.
|
|
.It Ar n Ns Ic \&~
|
|
Change the case of the next
|
|
.Ar n
|
|
characters.
|
|
.It Ar n Ns Ic y Ns Ar move-cmd
|
|
Yank from the current position to the position resulting from
|
|
.Ar n move-cmd Ns s
|
|
into the yank buffer; if
|
|
.Ar move-cmd
|
|
is
|
|
.Ic y ,
|
|
the whole line is yanked.
|
|
.It Ic Y
|
|
Yank from the current position to the end of the line.
|
|
.It Ar n Ns Ic p
|
|
Paste the contents of the yank buffer just after the current position,
|
|
.Ar n
|
|
times.
|
|
.It Ar n Ns Ic P
|
|
Same as
|
|
.Ic p ,
|
|
except the buffer is pasted at the current position.
|
|
.El
|
|
.Pp
|
|
Miscellaneous vi commands
|
|
.Bl -tag -width Ds
|
|
.It Ic ^J No and Ic ^M
|
|
The current line is read, parsed and executed by the shell.
|
|
.It Ic ^L No and Ic ^R
|
|
Redraw the current line.
|
|
.It Ar n Ns Ic \&.
|
|
Redo the last edit command
|
|
.Ar n
|
|
times.
|
|
.It Ic u
|
|
Undo the last edit command.
|
|
.It Ic U
|
|
Undo all changes that have been made to the current line.
|
|
.It Ar intr No and Ar quit
|
|
The interrupt and quit terminal characters cause the current line to be
|
|
deleted and a new prompt to be printed.
|
|
.El
|
|
.Sh FILES
|
|
.Bl -tag -width "/etc/suid_profile" -compact
|
|
.It Pa ~/.profile
|
|
.It Pa /etc/profile
|
|
.It Pa /etc/suid_profile
|
|
.El
|
|
.Sh SEE ALSO
|
|
.Xr arc4random 1 ,
|
|
.Xr awk 1 ,
|
|
.Xr csh 1 ,
|
|
.Xr ed 1 ,
|
|
.Xr getconf 1 ,
|
|
.Xr getopt 1 ,
|
|
.Xr sed 1 ,
|
|
.Xr sh 1 ,
|
|
.Xr stty 1 ,
|
|
.Xr vi 1 ,
|
|
.Xr dup 2 ,
|
|
.Xr execve 2 ,
|
|
.Xr getgid 2 ,
|
|
.Xr getuid 2 ,
|
|
.Xr open 2 ,
|
|
.Xr pipe 2 ,
|
|
.Xr wait 2 ,
|
|
.Xr getopt 3 ,
|
|
.Xr rand 3 ,
|
|
.Xr random 3 ,
|
|
.Xr signal 3 ,
|
|
.Xr srand 3 ,
|
|
.Xr srandom 3 ,
|
|
.Xr system 3 ,
|
|
.Xr tty 4 ,
|
|
.Xr environ 7
|
|
.Pp
|
|
.Pa http://docsrv.sco.com:507/en/man/html.C/sh.C.html
|
|
.Pp
|
|
.Rs
|
|
.%A Morris Bolsky
|
|
.%A David Korn
|
|
.%T "The KornShell Command and Programming Language"
|
|
.%D 1983
|
|
.%O "ISBN 0-13-516972-0"
|
|
.Re
|
|
.Rs
|
|
.%A Stephen G. Kochan
|
|
.%A Patrick H. Wood
|
|
.%T "UNIX Shell Programming"
|
|
.%O "Hayden"
|
|
.Re
|
|
.Rs
|
|
.%A "IEEE Inc."
|
|
.%T "IEEE Standard for Information Technology - Portable Operating System Interface (POSIX) - Part 2: Shell and Utilities"
|
|
.%D 1993
|
|
.%O "ISBN 1-55937-266-9"
|
|
.Re
|
|
.Sh VERSION
|
|
This page documents version @(#)PD KSH v5.2.14 99/07/13.2 of the public
|
|
domain Korn shell, as delivered with
|
|
.Mx .
|
|
.Sh NOTES
|
|
.Nm sh
|
|
is implemented as a run-time option of
|
|
.Nm mksh ,
|
|
with only those
|
|
.Nm ksh
|
|
features whose syntax or semantics are incompatible with a traditional Bourne
|
|
shell disabled.
|
|
Since this leaves some
|
|
.Nm ksh
|
|
extensions exposed, caution should be used where backwards compatibility with
|
|
traditional Bourne or
|
|
.Tn POSIX
|
|
compliant shells is an issue.
|
|
.Pp
|
|
.Nm mksh
|
|
is the name for the portable version of
|
|
.Mx
|
|
.Nm ksh
|
|
installed as
|
|
.Pa /bin/mksh
|
|
on other, foreign, operating systems.
|
|
Visit
|
|
.Pa http://wiki.mirbsd.de/MirbsdKsh
|
|
to obtain the latest version of
|
|
.Nm mksh .
|
|
.Sh AUTHORS
|
|
The
|
|
.Pa CONTRIBUTORS
|
|
file in the source distribution contains an almost complete list of people and
|
|
their part in the shell's development.
|
|
.Sh BUGS
|
|
Send bug reports for
|
|
.Nm
|
|
to the
|
|
.Mx
|
|
development team at
|
|
.Aq miros\-discuss@66h.42h.de .
|
|
Please include the version of
|
|
.Nm
|
|
.Po
|
|
.Ic print $KSH_VERSION
|
|
shows it
|
|
.Pc ,
|
|
the machine, operating system and compiler you are using and how you built
|
|
.Nm
|
|
(it is recommended to use the provided
|
|
.Pa Build.sh
|
|
mechanism)
|
|
and a description of how to repeat the bug (a small shell script that
|
|
demonstrates the bug is best).
|
|
The following, if relevant (if you are not sure, include them), can also be
|
|
helpful: options you are using (both
|
|
.Pa options.h
|
|
and
|
|
.Ic set Fl o Ic options )
|
|
and a copy of your
|
|
.Pa config.h
|
|
and
|
|
.Pa config.log
|
|
(the files generated by the
|
|
.Pa configure
|
|
script).
|
|
.Pp
|
|
By the way, the most frequently reported bug is:
|
|
.Bd -literal -offset indent
|
|
$ print hi | read a; print $a # Does not show hi
|
|
.Ed
|
|
.Pp
|
|
The
|
|
.Nm pdksh
|
|
author is aware of this and there is no need to report it.
|
|
For another known bug, refer to the comment above the
|
|
.Em complete-command
|
|
paragraph in the section
|
|
.Sx Emacs editing mode
|
|
above.
|