POSH(1)

NAME

posh - Policy-compliant Ordinary SHell

SYNOPSIS

posh [+-abCefhikmnprsuvxX] [+-o option]
     [[-c command-string [command-name] | -s | file ] [argument...]]

DESCRIPTION

posh is a reimplementation of the Bourne shell, a command interpreter for both interactive and script use.

Shell Startup

The following options can be specified only on the command line:

-c command-string

the shell executes the command(s) contained in command-string

-i

interactive mode -- see below

-l

login shell -- see below interactive mode -- see below

-s

the shell reads commands from standard input; all non-option
arguments are positional parameters

In addition to the above, the options described in the set builtin command can also be used on the command line.

If neither the -c nor the -s options are specified, the first
non-option argument specifies the name of a file the shell reads
commands from; if there are no non-option arguments, the shell reads
commands from standard input. The name of the shell (i.e., the contents of the $0) parameter is determined as follows: if the -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., argv[0]) is used.

A shell is interactive if the -i option is used or if both standard input and standard error are attached to a tty. An interactive shell
has job control enabled (if available), ignores the INT, QUIT and TERM signals, and prints prompts before reading input (see PS1 and PS2 parameters).

A shell is privileged if the -p option is used or if the real user-id or group-id does not match the effective user-id or group-id (see
getuid(2), getgid(2)). A privileged shell does not process $HOME/.profile nor the ENV parameter (see below), instead the file /etc/suid_profile is processed. Clearing the privileged option causes
the shell to set its effective user-id (group-id) to its real user-id
(group-id).

If the basename of the name the shell is called with (i.e., argv[0]) starts with - or if the -l option is used, the shell is assumed to be a login shell and the shell reads and executes the contents of
/etc/profile and $HOME/.profile if they exist and are readable.

If the 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 substitution and the
resulting file (if any) is read and executed. If ENV parameter is not set (and not null) and posh was compiled with the DEFAULT_ENV macro defined, the file named in that macro is included (after the above
mentioned substitutions have been performed).

The exit status of the shell is 127 if the command file specified on
the command line could not be opened, or non-zero if a fatal syntax
error occurred during the execution of a script. In the absence of
fatal errors, the exit status is that of the last command executed, or zero, if no command is executed.

Command Syntax

The shell begins parsing its input by breaking it into words. Words,
which are sequences of characters, are delimited by unquoted
white-space characters (space, tab and newline) or meta-characters (<, >, |, ;, &, ( and )). Aside from delimiting words, spaces and tabs are ignored, while newlines usually delimit commands. The meta-characters
are used in building the following tokens: <, <&, <<, >, >&, >>, etc.
are used to specify redirections (see Input/Output Redirection below);
| is used to create pipelines; ; is used to separate commands; & is
used to create asynchronous pipelines; && and || are used to specify
conditional execution; ;; is used in case statements; and lastly, ( )
are used to create subshells.

White-space and meta-characters can be quoted individually using
backslash (\), or in groups using double (") or single (') quotes. Note that the following characters are also treated specially by the shell
and must be quoted if they are to represent themselves: \, ", ', #, $, `, ~, {, }, *, ? and [. The first three of these are the above mentioned quoting characters (see Quoting below); #, if used at the
beginning of a word, introduces a comment -- everything after the # up to the nearest newline is ignored; $ is used to introduce parameter, command and arithmetic substitutions (see Substitution below); `
introduces an old-style command substitution (see Substitution below);
~ begins a directory expansion (see Tilde Expansion below); { and } delimit csh(1) style alternations (see Brace Expansion below); and, finally, *, ? and [ are used in file name generation (see File Name Patterns below).

As words and tokens are parsed, the shell builds commands, of which
there are two basic types: simple-commands, typically programs that are executed, and compound-commands, such as for and if statements, grouping constructs and function definitions.

A simple-command consists of some combination of parameter assignments (see Parameters below), input/output redirections (see Input/Output
Redirections below), and command words; the only restriction is that
parameter assignments come before any command words. The command words, if any, define the command that is to be executed and its arguments.
The command may be a shell built-in command, a function or an external command, i.e., a separate executable file that is located using the PATH parameter (see Command Execution below). Note that all command constructs have an exit status: for external commands, this is related to the status returned by 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 zero if there were no command substitutions.

Commands can be chained together using the | token to form pipelines, in which the standard output of each command but the last is piped (see 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 ! reserved word which causes the exit status of the pipeline to be logically complemented: if the original status was 0 the complemented status will be 1, and if the original status was not 0,
then the complemented status will be 0.

Lists of commands can be created by separating pipelines by any of the following tokens: &&, ||, &, |& and ;. The first two are for conditional execution: cmd1 && cmd2 executes cmd2 only if the exit status of cmd1 is zero; || is the opposite -- cmd2 is executed only if the exit status of cmd1 is non-zero. && and || have equal precedence which is higher than that of &, |& and ;, which also have equal precedence. The & 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 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 INT and QUIT ignored and with input redirected from /dev/null (however, redirections specified
in the asynchronous command have precedence). Note that a command must follow the && and || operators, while a command need not follow &, |& and ;. The exit status of a list is that of the last command executed, with the exception of asynchronous lists, for which the exit status is 0.

Compound commands 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):

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

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 exec statement should be used instead to redirect file descriptors before the control structure.

In the following compound command descriptions, command lists (denoted as list) that are followed by reserved words must end with a
semi-colon, a newline or a (syntactically correct) reserved word. For
example,

{ echo foo; echo bar; }

{ echo foo; echo bar<newline>}

{ { echo foo; echo bar; } } are all valid, but

{ echo foo; echo bar } is not.

( list )

Execute list in a subshell. There is no implicit way to pass environment changes from a subshell back to its parent.

{ list }

Compound construct; list is executed, but not in a subshell. Note that { and } are reserved words, not meta-characters.

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

The case statement attempts to match word against the specified patterns; the list associated with the first successfully matched pattern is executed. Patterns used in case statements are the same as those used for file name patterns except that the restrictions
regarding . and / are dropped. Note that any unquoted space before and after a pattern is stripped; any space with a pattern must be
quoted. Both the word and the patterns are subject to parameter,
command, and arithmetic substitution as well as tilde substitution. For historical reasons, open and close braces may be used instead
of in and esac (e.g., case $foo { *) echo bar; }). The exit status of a case statement is that of the executed list; if no list is executed, the exit status is zero.

for name [ in word ... term ] do list done

where term is either a newline or a ;. For each word in the specified word list, the parameter name is set to the word and list is executed. If in is not used to specify a word list, the
positional parameters ("$1", "$2", etc.) are used instead. For historical reasons, open and close braces may be used instead of do and done (e.g., for i; { echo $i; }). The exit status of a for statement is the last exit status of list; if list is never executed, the exit status is zero.

if list then list [elif list then list] ... [else list] fi

If the exit status of the first list is zero, the second list is executed; otherwise the list following the elif, if any, is executed with similar consequences. If all the lists following the if and elifs fail (i.e., exit with non-zero status), the list following the else is executed. The exit status of an if statement is that of non-conditional list that is executed; if no
non-conditional list is executed, the exit status is zero.

until list do list done

This works like while, except that the body is executed only while the exit status of the first list is non-zero.

while list do list done

A while is a prechecked loop. Its body is executed as often as the exit status of the first list is zero. The exit status of a while statement is the last exit status of the list in the body of the loop; if the body is not executed, the exit status is zero.

name () command

Defines the function name. See Functions below. Note that
redirections specified after a function definition are performed
whenever the function is executed, not when the function definition is executed.

time [ -p ] [ pipeline ]

The time reserved word is described in the Command Execution section.

Quoting

Quoting is used to prevent the shell from treating characters or words specially. There are three methods of quoting: First, \ quotes the
following character, unless it is at the end of a line, in which case
both the \ and the newline are stripped. Second, a single quote (') quotes everything up to the next single quote (this may span lines).
Third, a double quote (") quotes all characters, except $, ` and \, up to the next unquoted double quote. $ and ` 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 \ inside a double-quoted string is followed by \, $, ` or ", it is replaced by the second character; if it is followed by a newline, both the \ and the newline are stripped;
otherwise, both the \ and the character following are unchanged.

Note: see POSIX Mode below for a special rule regarding sequences of
the form "...`...\"...`..".

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 $name or ${...}; command substitutions take the form $(command) or `command`; and arithmetic substitutions take the form $((expression)).

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 IFS parameter. The 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 IFS characters are called IFS white space. Sequences of one or more IFS white space characters, in combination with zero or one
non-IFS white space characters delimit a field. As a special case,
leading and trailing IFS white space is stripped (i.e., no leading or trailing empty field is created by it); leading or trailing non-IFS
white space does create an empty field. Example: if IFS is set to `<space>:', the sequence of characters
`<space>A<space>:<space><space>B::D' contains four fields: `A', `B', `' and `D'. Note that if the 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.

The results of substitution are, unless otherwise specified, also
subject to brace expansion and file name expansion (see the relevant
sections below).

A command substitution is replaced by the output generated by the
specified command, which is run in a subshell. For $(command) substitutions, normal quoting rules are used when command is parsed, however, for the `command` form, a \ followed by any of $, ` or \ is stripped (a \ followed by any other character is unchanged). As a
special case in command substitutions, a command of the form < file is interpreted to mean substitute the contents of file ($(< foo) has the same effect as $(cat foo), but it is carried out more efficiently
because no process is started).

NOTE: $(command) expressions are currently parsed by finding the matching parenthesis, regardless of quoting. This will hopefully be
fixed soon.

Arithmetic substitutions are replaced by the value of the specified
expression. For example, the command echo $((2+3*4)) prints 14. See Arithmetic Expressions for a description of an expression.

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 (`_' counts as a letter). The later form can be
treated as arrays by appending an array index of the form: [expr] where expr is an arithmetic expression. Array indices are currently limited to the range 0 through 1023, inclusive. Parameter substitutions take
the form $name, ${name} or ${name[expr]}, where 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 nounset option (set -o nounset or set -u) is set, in which case an error occurs.

Parameters can be assigned values in a number of ways. First, the shell implicitly sets some parameters like #, 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, `FOO=bar' sets the parameter FOO to 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 = must be unquoted for the shell to recognize a parameter assignment. The fourth way of
setting a parameter is with the export and readonly commands; see their descriptions in the Command Execution section. Fifth, for and select loops set parameters as well as the getopts, read and set -A commands. Lastly, parameters can be assigned values using assignment operators
inside arithmetic expressions (see Arithmetic Expressions below) or
using the ${name=value} form of parameter substitution (see below).

Parameters with the export attribute (set using the export command, or by parameter assignments followed by simple commands) are put in the
environment (see environ(5)) of commands run by the shell as name=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.

Modifiers can be applied to the ${name} form of parameter substitution:

${name:-word}

if name is set and not null, it is substituted, otherwise word is substituted.

${name:+word}

if name is set and not null, word is substituted, otherwise nothing is substituted.

${name:=word}

if name is set and not null, it is substituted, otherwise it is assigned word and the resulting value of name is substituted.

${name:?word}

if name is set and not null, it is substituted, otherwise word is printed on standard error (preceded by name:) and an error occurs (normally causing termination of a shell script, function or
.-script). If word is omitted the string `parameter null or not
set' is used instead.

In the above modifiers, the : can be omitted, in which case the
conditions only depend on name being set (as opposed to set and not null). If word is needed, parameter, command, arithmetic and tilde substitution are performed on it; if word is not needed, it is not evaluated.

The following forms of parameter substitution can also be used:

${#name}

The number of positional parameters if name is *, @ or is not specified, or the length of the string value of parameter name.

${#name[*]}, ${#name[@]}

The number of elements in the array name.

${name#pattern}, ${name##pattern}

If pattern matches the beginning of the value of parameter name, the matched text is deleted from the result of substitution. A
single # results in the shortest match, two #'s results in the longest match.

${name%pattern}, ${name%%pattern}

Like ${..#..} substitution, but it deletes from the end of the value.

The following special parameters are implicitly set by the shell and
cannot be set directly using assignments:

!

Process id of the last background process started. If no background processes have been started, the parameter is not set.

#

The number of positional parameters (i.e., $1, $2, etc.).

$

The process ID of the shell, or the PID of the original shell if it is a subshell.

BUILTIN UTILITIES

posh implements the following builtin utilities:

o .

o :

o [

o break

o builtin

o continue

o eval

o exec

o exit

o false

o return

o set

o shift

o times

o trap

o wait

o read

o test

o true

o umask

o unset

o cd

o command

o echo

o export

o getopts

o kill

o local

o pwd

o readonly

FILES

~/.profile
/etc/profile
/etc/suid_profile

BUGS

Any bugs in posh should be reported via the Debian BTS. Legitimate bugs are inconsistencies between manpage and behavior, and inconsistencies
between behavior and Debian policy (currently SUSv3 compliance with the following exceptions: echo -n, binary -a and -o to test, local
scoping).

VERSION

This page documents the Policy-compliant Ordinary SHell.

AUTHORS

This shell is based on pdksh.

SEE ALSO

awk(1), ksh(1), dash(1), ed(1), getconf(1), getopt(1), sed(1), stty(1), vi(1), dup(2), execve(2), getgid(2), getuid(2), open(2), pipe(2), wait(2), getopt(3), rand(3), signal(3), system(3), environ(5)

March 14, 2008 03/28/2008 POSH(1)