Basic Shell Features

N.B.
• if needs  space before [
• [ x comparison y ] needs spaces around comparison

The very simple (but not as clear)
If first command works, execute second command
./setup.sh && ./process.sh


If first command fails, execute second command
./checkIt || { echo "checkIt failed" ; exit 1; }

(see Lists of Commands )

select

select name [in words … ]; do commands; done

1. The list of words is expanded, generating a list of items.
2. These items are printed on the standard error output stream, each preceded by a number. If the in words is omitted, the positional parameters are printed, as if in "$@" had been specifed.
3. The PS3 prompt is then displayed and a line is read from the standard input.
4. If the line consists of a number corresponding to one of the displayed words, then the value of name is set to that word. If the line is empty, the words and prompt are displayed again.
5. Other values causes name to be set to null.
6. If EOF is read, the select command completes. The line read is saved in the variable REPLY.
7. The commands are executed after each selection until a break or return command is executed, at which point the select command completes.

 select fname in  0.sh birdloger* *.sed ;
      do  
        echo you picked $fname \($REPLY\);    
        break;       
      done 

1) 0.sh                     3) birdloger.pl             5) log-summ.sed
2) birdloger.html           4) birdlogmail2content.sed  6) lslrClean.sed
#? 3
you picked birdloger.pl (3) 

Functions

Declared using :
[ function ] func () { command-list; }

The reserved word function is optional, if supplied the parentheses are optional.
The command-list is executed when func is specified as the name of a command.

Functions can be defined within a script or in a file but must be defined before they are invoked.

To include a file containing functions use

. fileWithFuncs

When a function is entered, the arguments are the positional parameters.
The number of positional parameters ($#) indicates the number of arguments. Positional parameter $0 is unchanged.

The exit status of a function is the exit status of the last command executed in the command-list or the value supplied by return n.
When the function completes, execution resumes with the command after the function call, the values of the positional parameters and the $# are restored

Variables local to the function may be declared with the local builtin making them are accessible only to the function and the commands it invokes.

Functions may be recursive. No limit is placed on the number of recursive calls.

Example:

> echo $0
-bash
> cat resetfile.fun
resetfile(){
echo $0
echo $1
if [ -e $1 ]; then rm $1;fi
touch $1
chmod 755 $1
}
> . resetfile.fun
> resetFile output1
-bash           notice that $0 reflects the caller of the script not the function
output1
>ls -l output1
-rwxr-xr-x 1 me mygroup 0 Oct 7 13:21 0


Shell Parameters

A parameter is set if it has been assigned a value.
The null string is a valid value.
Once a variable is set, it may be unset only by using the unset builtin.

A variable may be assigned to by a statement of the form

  name=[value]

If value is not given, the variable is assigned the null string.
All values undergo tilde expansion, parameter and variable expansion, command substitution, arithmetic expansion, and quote removal .
If the variable has its integer attribute set (see declare), then value is subject to arithmetic expansion even if the $((...)) expansion is not used (see Arithmetic Expansion).

Word splitting is not performed, with the exception of "$@" .
Filename expansion is not performed.

Positional Parameters

A positional parameter is a parameter denoted by $ and one or more digits. ($0 is a 'Special' parameter.)
Positional parameters are assigned from the shell's arguments when it is invoked, and
may be reassigned using set , but not with assignment statements.
Positional parameter $N may be referenced as ${N}.
They are temporarily replaced when a function is executed .

When a positional parameter consisting of more than a single digit is expanded, it must be enclosed in braces.

Expansions

Redirections

Here Documents

No parameter expansion, command substitution, filename expansion, or arithmetic expansion is performed on word.
If any characters in word are quoted, the delimiter is the result of quote removal on word, and the lines in the here-document are not expanded.
If word is unquoted, all lines of the here-document are subjected to parameter expansion, command substitution, and arithmetic expansion.
The pair \newline is ignored, and \ must be used to quote the characters \, $, and `.

<<- all leading tab characters are stripped from input lines and the line containing delimiter. This allows here-documents within shell scripts to be indented in a natural fashion.

Duplicating File Descriptors

duplicates input file descriptors.
If n is not specified, the STDIN (file descriptor 0) is used. If fdes expands to one or more digits, the file descriptor (n) becomes a copy of that file descriptor.
If the digits in fdes do not specify a file descriptor open for input, a redirection error occurs.
If fdes evaluates to -, file descriptor n is closed.

[n]>&fdes duplicates output file descriptors.
If n is not specified, the standard output (file descriptor 1) is used.
If the digits in fdes do not specify a file descriptor open for output, a redirection error occurs. As a special case, if n is omitted, and fdes does not expand to one or more digits, STDOUT and STDERR are redirected .

Moving File Descriptors

[n]<&d-

moves the file descriptor d to file descriptor n, or the standard input if n is not specified.
d is closed after being duplicated to n.

[n]&d-

moves the file descriptor d to file descriptor n, or the standard output ifd is not specified.

Opening File Descriptors for Reading and Writing

Executing Commands

Simple Command Expansion

When a simple command is executed, the shell performs the following operations from left to right.

1. Expanions are performed.
2. The first word is taken to be the name of the command and the remaining words are the arguments.
3. Redirections are performed
4. The text after the = in each variable assignment undergoes tilde expansion, parameter expansion, command substitution, arithmetic expansion, and quote removal before being assigned to the variable.

   variable=`ls ~/*.sh`
   /Users/me > echo $variable
   /Users/me/LibraryClean.sh /Users/me/net.sh /Users/me/pocketForCordury.shA

   If no command name results, the variable assignments affect the current shell environment. Otherwise, the variables are added to the environment of the executed command and do not affect the current shell environment.
   

   If no command name results, redirections are performed, but do not affect the current shell environment.

   If there is a command name left after expansion, execution proceeds as described below. Otherwise, the command exits.

   If one of the expansions contained a command substitution, the exit status of the command is the exit status of the last command substitution performed. If there were no command substitutions, the command exits with a status of zero.

Command Search and Execution

After a command has been split into words, if it results in a simple command and an optional list of arguments, the following actions are taken.
If the command name contains no slashes, the shell attempts to locate it checking for a:

1. function
2. builtin
3. element of $PATH for a directory containing an executable file.
   (Bash uses a hash table to remember the full pathnames of executable files to avoid multiple PATH searches (see the description of hash in section Bourne Shell Builtins, this may be a problem if the file is created during the shell execution. A full search of the directories in $PATH is performed only if the command is not found in the hash table. )
   If the search is unsuccessful, the shell outputs an error message and returns an exit status of 127.
4. If the search is successful, or if the command name contains one or more slashes,
   the shell executes the named program in a separate execution environment.
   Argument 0 is set to the name given, and the remaining arguments to the command are set to the arguments supplied.
5. If this execution fails because the file is not in executable format, and the file is not a directory, it is assumed to be a shell script and the shell executes it as described in section Shell Scripts.
6. the shell waits for the command to complete and collects its exit status, unless the command was begun asynchronously using the &

The status of a simple command is its exit status as provided by the POSIX.1 waitpid function, or 128+n if the command was terminated by signal†??(_) n.

Command Execution Environment

The shell has an execution environment, which consists of :

• open files inherited by the shell at invocation, as modified by redirections supplied to the exec builtin
• the current working directory as set by cd, pushd, or popd, or inherited by the shell at invocation
• the file creation mode mask as set by umask or inherited from the shell's parent
• traps set by trap
• shell parameters that are set by variable assignment or with set or inherited from the shell's parent in the environment
• shell functions defined during execution or inherited from the shell's parent in the environment
• options enabled at invocation (either by default or with command-line arguments) or by set
• options enabled by shopt
• aliases
• various process IDs, including those of background jobs (see Lists of Commands), the value of $$, and the value of $PPID

When a simple command other than a builtin or shell function is to be executed,(among other things ) it is invoked in a separate execution environment that consists of:

• the open files, plus any modifications and additions specified by redirections to the command
• the current working directory
• the file creation mode mask
• variables marked for export, along with variables exported for the command, passed in the environment
• traps caught by the shell are reset to the values inherited from the shell's parent, and traps ignored by the shell are ignored

A command invoked in this separate environment cannot affect the calling shell's execution environment.

Command substitution and asynchronous commands are invoked in a subshell environment that is a duplicate of the shell environment, except that traps caught by the shell are reset to the values that the shell inherited from its parent at invocation.

Builtin commands that are invoked as part of a pipeline are also executed in a subshell environment.
Changes made to the subshell environment cannot affect the shell's execution environment.

Environment

On invocation, the shell marks each parameter export to child processes.
Executed commands inherit the environment.
unset, export and declare add/delete parameters and functions to/from the environment.

The environment for any simple command or function may be augmented temporarily by prefixing it with parameter assignments, as described in Shell Parameters.
These assignment statements affect only the environment seen by that command.

With -k (The Set Builtin), all parameter assignments are placed in the environment for a command, not just those that precede the command name.

When Bash invokes an external command, the variable $_ is set to the full path name of the command and is included in the environment.

Exit Status

The exit status is used by the Conditional Constructs and some of the list constructs .

All builtins return an exit status of 2 to indicate incorrect usage.

Signals

If BASH receives a signal, for which a trap has been set, while waiting for a command to complete, the trap will not be executed until the command completes.
If waiting for an asynchronus command an exit status greater than 128 is set, then trap is executed.

Commands started by Bash have signal handlers set to the values inherited by the shell from its parent.

Shell Scripts

The special parameter $0 is set to the name of the file (rather than the name of the shell), and the positional parameters are set to the remaining arguments.

When Bash finds such a file in the $PATH for a command, it spawns a subshell to execute it. In other words, executing

file arguments ^†

bash file arguments ^†

This subshell initializes itself, so that the effect is as if a new shell had been invoked to interpret the script, with the exception that the locations of commands remembered by the parent (see the description of hash in Bourne Shell Builtins) are retained by the child.

If the first line of a script begins with #!, the remainder of the line specifies an interpreter for the the script, followed by the arguments.

For example:

#!/usr/bin/perl -w

See chmod regarding setting permissions.