bash.1

android-w.song.android.widget

.BR identifier .
.TP
.B metacharacter
A character that, when unquoted, separates words.  One of the following:
.br
.RS
.PP
.if t \fB|  &  ;  (  )  <  >  space  tab\fP
.if n \fB|  & ; ( ) < > space tab\fP
.RE
.PP
.TP
.B control operator
A \fItoken\fP that performs a control function.  It is one of the following
symbols:
.RS
.PP
.if t \fB||  &  &&  ;  ;;  (  )  |  |&    <newline>\fP
.if n \fB|| & && ; ;; ( ) | |& <newline>\fP
.RE
.PD
.SH "RESERVED WORDS"
\fIReserved words\fP are words that have a special meaning to the shell.
The following words are recognized as reserved when unquoted and either
the first word of a simple command (see
.SM
.B SHELL GRAMMAR
below) or the third word of a 
.B case 
or
.B for
command:
.if t .RS
.PP
.B
.if n ! case  do done elif else esac fi for function if in select then until while { } time [[ ]]
.if t !    case    do    done    elif    else    esac    fi    for    function    if    in    select    then    until    while    {    }    time    [[    ]]
.if t .RE
.SH "SHELL GRAMMAR"
.SS Simple Commands
.PP
A \fIsimple command\fP is a sequence of optional variable assignments
followed by \fBblank\fP-separated words and redirections, and
terminated by a \fIcontrol operator\fP.  The first word
specifies the command to be executed, and is passed as argument zero.
The remaining words are passed as arguments to the invoked command.
.PP
The return value of a \fIsimple command\fP is its exit status, or
128+\fIn\^\fP if the command is terminated by signal
.IR n .
.SS Pipelines
.PP
A \fIpipeline\fP is a sequence of one or more commands separated by
one of the control operators
.B |
or \fB|&\fP.
The format for a pipeline is:
.RS
.PP
[\fBtime\fP [\fB\-p\fP]] [ ! ] \fIcommand\fP [ [\fB|\fP\(bv\fB|&\fP] \fIcommand2\fP ... ]
.RE
.PP
The standard output of
.I command
is connected via a pipe to the standard input of
.IR command2 .
This connection is performed before any redirections specified by the
command (see
.SM
.B REDIRECTION
below).
If \fB|&\fP is used, the standard error of \fIcommand\fP is connected to
\fIcommand2\fP's standard input through the pipe; it is shorthand for
\fB2>&1 |\fP.
This implicit redirection of the standard error is performed after any
redirections specified by the command.
.PP
The return status of a pipeline is the exit status of the last
command, unless the \fBpipefail\fP option is enabled.
If \fBpipefail\fP is enabled, the pipeline's return status is the
value of the last (rightmost) command to exit with a non-zero status,
or zero if all commands exit successfully.
If the reserved word
.B !
precedes a pipeline, the exit status of that pipeline is the logical
negation of the exit status as described above.
The shell waits for all commands in the pipeline to
terminate before returning a value.
.PP
If the
.B time
reserved word precedes a pipeline, the elapsed as well as user and
system time consumed by its execution are reported when the pipeline
terminates.
The \fB\-p\fP option changes the output format to that specified by POSIX.
When the shell is in \fIposix mode\fP, it does not recognize
\fBtime\fP as a reserved word if the next token begins with a `-'.
The
.SM
.B TIMEFORMAT
variable may be set to a format string that specifies how the timing
information should be displayed; see the description of
.SM
.B TIMEFORMAT
under
.B "Shell Variables"
below.
.PP
When the shell is in \fIposix mode\fP, \fBtime\fP
may be followed by a newline.  In this case, the shell displays the
total user and system time consumed by the shell and its children.
The
.SM
.B TIMEFORMAT
variable may be used to specify the format of
the time information.
.PP
Each command in a pipeline is executed as a separate process (i.e., in a
subshell).
.SS Lists
.PP
A \fIlist\fP is a sequence of one or more pipelines separated by one
of the operators
.BR ; ,
.BR & ,
.BR && ,
or
.BR || ,
and optionally terminated by one of
.BR ; ,
.BR & ,
or
.BR <newline> .
.PP
Of these list operators,
.B &&
and
.B ||
have equal precedence, followed by
.B ;
and
.BR & ,
which have equal precedence.
.PP
A sequence of one or more newlines may appear in a \fIlist\fP instead
of a semicolon to delimit commands.
.PP
If a command is terminated by the control operator
.BR & ,
the shell executes the command in the \fIbackground\fP
in a subshell.  The shell does not wait for the command to
finish, and the return status is 0.  Commands separated by a
.B ;
are executed sequentially; the shell waits for each
command to terminate in turn.  The return status is the
exit status of the last command executed.
.PP
AND and OR lists are sequences of one of more pipelines separated by the
\fB&&\fP and \fB||\fP control operators, respectively.
AND and OR lists are executed with left associativity.
An AND list has the form
.RS
.PP
\fIcommand1\fP \fB&&\fP \fIcommand2\fP
.RE
.PP
.I command2
is executed if, and only if,
.I command1
returns an exit status of zero.
.PP
An OR list has the form
.RS
.PP
\fIcommand1\fP \fB||\fP \fIcommand2\fP
.PP
.RE
.PP
.I command2
is executed if and only if
.I command1
returns a non-zero exit status.
The return status of
AND and OR lists is the exit status of the last command
executed in the list.
.SS Compound Commands
.PP
A \fIcompound command\fP is one of the following:
.TP
(\fIlist\fP)
\fIlist\fP is executed in a subshell environment (see
.SM
\fBCOMMAND EXECUTION ENVIRONMENT\fP
below).
Variable assignments and builtin
commands that affect the shell's environment do not remain in effect
after the command completes.  The return status is the exit status of
\fIlist\fP.
.TP
{ \fIlist\fP; }
\fIlist\fP is simply executed in the current shell environment.
\fIlist\fP must be terminated with a newline or semicolon.
This is known as a \fIgroup command\fP.
The return status is the exit status of
\fIlist\fP.
Note that unlike the metacharacters \fB(\fP and \fB)\fP, \fB{\fP and
\fB}\fP are \fIreserved words\fP and must occur where a reserved
word is permitted to be recognized.  Since they do not cause a word
break, they must be separated from \fIlist\fP by whitespace or another
shell metacharacter.
.TP
((\fIexpression\fP))
The \fIexpression\fP is evaluated according to the rules described
below under
.SM
.BR "ARITHMETIC EVALUATION" .
If the value of the expression is non-zero, the return status is 0;
otherwise the return status is 1.  This is exactly equivalent to
\fBlet "\fIexpression\fP"\fR.
.TP
\fB[[\fP \fIexpression\fP \fB]]\fP
Return a status of 0 or 1 depending on the evaluation of
the conditional expression \fIexpression\fP.
Expressions are composed of the primaries described below under
.SM
.BR "CONDITIONAL EXPRESSIONS" .
Word splitting and pathname expansion are not performed on the words
between the \fB[[\fP and \fB]]\fP; tilde expansion, parameter and
variable expansion, arithmetic expansion, command substitution, process
substitution, and quote removal are performed.
Conditional operators such as \fB\-f\fP must be unquoted to be recognized
as primaries.
.if t .sp 0.5
.if n .sp 1
When used with \fB[[\fP, the \fB<\fP and \fB>\fP operators sort
lexicographically using the current locale.
.if t .sp 0.5
.if n .sp 1
When the \fB==\fP and \fB!=\fP operators are used, the string to the
right of the operator is considered a pattern and matched according
to the rules described below under \fBPattern Matching\fP.
If the shell option
.B nocasematch
is enabled, the match is performed without regard to the case
of alphabetic characters.
The return value is 0 if the string matches (\fB==\fP) or does not match
(\fB!=\fP) the pattern, and 1 otherwise.
Any part of the pattern may be quoted to force it to be matched as a
string.
.if t .sp 0.5
.if n .sp 1
An additional binary operator, \fB=~\fP, is available, with the same
precedence as \fB==\fP and \fB!=\fP.
When it is used, the string to the right of the operator is considered
an extended regular expression and matched accordingly (as in \fIregex\fP(3)).  
The return value is 0 if the string matches
the pattern, and 1 otherwise.
If the regular expression is syntactically incorrect, the conditional
expression's return value is 2.
If the shell option
.B nocasematch
is enabled, the match is performed without regard to the case
of alphabetic characters.
Any part of the pattern may be quoted to force it to be matched as a
string.
Substrings matched by parenthesized subexpressions within the regular
expression are saved in the array variable
.SM
.BR BASH_REMATCH .
The element of
.SM
.B BASH_REMATCH
with index 0 is the portion of the string
matching the entire regular expression.
The element of
.SM
.B BASH_REMATCH
with index \fIn\fP is the portion of the
string matching the \fIn\fPth parenthesized subexpression.
.if t .sp 0.5
.if n .sp 1
Expressions may be combined using the following operators, listed
in decreasing order of precedence:
.if t .sp 0.5
.if n .sp 1
.RS
.PD 0
.TP
.B ( \fIexpression\fP )
Returns the value of \fIexpression\fP.
This may be used to override the normal precedence of operators.
.TP
.B ! \fIexpression\fP
True if
.I expression
is false.
.TP
\fIexpression1\fP \fB&&\fP \fIexpression2\fP
True if both
.I expression1
and
.I expression2
are true.
.TP
\fIexpression1\fP \fB||\fP \fIexpression2\fP
True if either
.I expression1
or
.I expression2
is true.
.PD
.LP
The \fB&&\fP and \fB||\fP
operators do not evaluate \fIexpression2\fP if the value of
\fIexpression1\fP is sufficient to determine the return value of
the entire conditional expression.
.RE
.TP
\fBfor\fP \fIname\fP [ [ \fBin\fP [ \fIword ...\fP ] ] ; ] \fBdo\fP \fIlist\fP ; \fBdone\fP
The list of words following \fBin\fP is expanded, generating a list
of items.
The variable \fIname\fP is set to each element of this list
in turn, and \fIlist\fP is executed each time.
If the \fBin\fP \fIword\fP is omitted, the \fBfor\fP command executes
\fIlist\fP once for each positional parameter that is set (see
.SM
.B PARAMETERS
below).
The return status is the exit status of the last command that executes.
If the expansion of the items following \fBin\fP results in an empty
list, no commands are executed, and the return status is 0.
.TP
\fBfor\fP (( \fIexpr1\fP ; \fIexpr2\fP ; \fIexpr3\fP )) ; \fBdo\fP \fIlist\fP ; \fBdone\fP
First, the arithmetic expression \fIexpr1\fP is evaluated according
to the rules described below under
.SM
.BR "ARITHMETIC EVALUATION" .
The arithmetic expression \fIexpr2\fP is then evaluated repeatedly
until it evaluates to zero.
Each time \fIexpr2\fP evaluates to a non-zero value, \fIlist\fP is
executed and the arithmetic expression \fIexpr3\fP is evaluated.
If any expression is omitted, it behaves as if it evaluates to 1.
The return value is the exit status of the last command in \fIlist\fP
that is executed, or false if any of the expressions is invalid.
.TP
\fBselect\fP \fIname\fP [ \fBin\fP \fIword\fP ] ; \fBdo\fP \fIlist\fP ; \fBdone\fP
The list of words following \fBin\fP is expanded, generating a list
of items.  The set of expanded words is printed on the standard
error, each preceded by a number.  If the \fBin\fP
\fIword\fP is omitted, the positional parameters are printed (see
.SM
.B PARAMETERS
below).  The
.SM
.B PS3
prompt is then displayed and a line read from the standard input.
If the line consists of a number corresponding to one of
the displayed words, then the value of
.I name
is set to that word.  If the line is empty, the words and prompt
are displayed again.  If EOF is read, the command completes.  Any
other value read causes
.I name
to be set to null.  The line read is saved in the variable
.SM
.BR REPLY .
The
.I list
is executed after each selection until a
.B break
command is executed.
The exit status of
.B select
is the exit status of the last command executed in
.IR list ,
or zero if no commands were executed.
.TP
\fBcase\fP \fIword\fP \fBin\fP [ [(] \fIpattern\fP [ \fB|\fP \fIpattern\fP ] \
... ) \fIlist\fP ;; ] ... \fBesac\fP
A \fBcase\fP command first expands \fIword\fP, and tries to match
it against each \fIpattern\fP in turn, using the same matching rules
as for pathname expansion (see
.B Pathname Expansion
below).
The \fIword\fP is expanded using tilde
expansion, parameter and variable expansion, arithmetic substitution,
command substitution, process substitution and quote removal.
Each \fIpattern\fP examined is expanded using tilde
expansion, parameter and variable expansion, arithmetic substitution,
command substitution, and process substitution.
If the shell option
.B nocasematch
is enabled, the match is performed without regard to the case
of alphabetic characters.
When a match is found, the corresponding \fIlist\fP is executed.
If the \fB;;\fP operator is used, no subsequent matches are attempted after
the first pattern match.
Using \fB;&\fP in place of \fB;;\fP causes execution to continue with
the \fIlist\fP associated with the next set of patterns.
Using \fB;;&\fP in place of \fB;;\fP causes the shell to test the next
pattern list in the statement, if any, and execute any associated \fIlist\fP
on a successful match.
The exit status is zero if no
pattern matches.  Otherwise, it is the exit status of the
last command executed in \fIlist\fP.
.TP
\fBif\fP \fIlist\fP; \fBthen\fP \fIlist;\fP \
[ \fBelif\fP \fIlist\fP; \fBthen\fP \fIlist\fP; ] ... \
[ \fBelse\fP \fIlist\fP; ] \fBfi\fP
The
.B if 
.I list
is executed.  If its exit status is zero, the
\fBthen\fP \fIlist\fP is executed.  Otherwise, each \fBelif\fP
\fIlist\fP is executed in turn, and if its exit status is zero,
the corresponding \fBthen\fP \fIlist\fP is executed and the
command completes.  Otherwise, the \fBelse\fP \fIlist\fP is
executed, if present.  The exit status is the exit status of the
last command executed, or zero if no condition tested true.
.TP
\fBwhile\fP \fIlist-1\fP; \fBdo\fP \fIlist-2\fP; \fBdone\fP
.PD 0
.TP
\fBuntil\fP \fIlist-1\fP; \fBdo\fP \fIlist-2\fP; \fBdone\fP
.PD
The \fBwhile\fP command continuously executes the list
\fIlist-2\fP as long as the last command in the list \fIlist-1\fP returns
an exit status of zero.  The \fBuntil\fP command is identical
to the \fBwhile\fP command, except that the test is negated;
.I list-2
is executed as long as the last command in
.I list-1
returns a non-zero exit status.
The exit status of the \fBwhile\fP and \fBuntil\fP commands
is the exit status
of the last command executed in \fIlist-2\fP, or zero if
none was executed.
.SS Coprocesses
.PP
A \fIcoprocess\fP is a shell command preceded by the \fBcoproc\fP reserved
word.
A coprocess is executed asynchronously in a subshell, as if the command
had been terminated with the \fB&\fP control operator, with a two-way pipe
established between the executing shell and the coprocess.
.PP
The format for a coprocess is:
.RS
.PP
\fBcoproc\fP [\fINAME\fP] \fIcommand\fP [\fIredirections\fP]
.RE
.PP
This creates a coprocess named \fINAME\fP.
If \fINAME\fP is not supplied, the default name is \fICOPROC\fP.
\fINAME\fP must not be supplied if \fIcommand\fP is a \fIsimple
command\fP (see above); otherwise, it is interpreted as the first word
of the simple command.
When the coproc is executed, the shell creates an array variable (see
.B Arrays
below) named \fINAME\fP in the context of the executing shell.
The standard output of
.I command