Unix Bourne Shell Scripts

The Bourne shell supports variables

-----------------------------------------------------
H=hello
echo $H
export H
-----------------------------------------------------

Many predefined shell variables exist
```
$HOME
$PATH
...
```

Script files

Any list of commands can be put into a file (e.g. pgm) and run by:
```
$ sh pgm
```
or
```
$ chmod +x pgm

$ pgm
```

Sample script

#!/bin/sh>

# Sample Bourne shell script

echo Hello $USER from program $0

The First line (#!/bin/sh) signifies that a new Bourne shell process is spawned.

Conditional Branching

If-then-else constructs

-------------------------------------------------
                                                   
if test command(s)
then command(s)
elif command(s)
else command(s)
fi

-or-
if test commands(s) ; then commands(s) ; fi
                                                   
-------------------------------------------------

The 'test commands' may be the actual test command (e.g., "test expr"), or its shell equivalent, "[ expr ]".

     test expr
     [ expr ]

     test evaluates the expression expr and, if its value is true, sets
     a zero (true) exit status; otherwise, a non-zero (false) exit
     status is set; test also sets a non-zero exit status if there are
     no arguments.  When permissions are tested, the effective user ID
     of the process is used.

     All operators, flags, and brackets (brackets used as shown in the
     second SYNOPSIS line) must be separate arguments to the test
     command; normally these items are separated by spaces.  The
     following primitives are used to construct expr:

     -r file     true if file exists and is readable.

     -l file     true if file exists and is a symbolic link.

     -w file     true if file exists and is writable.

     -x file     true if file exists and is executable.

     -f file     true if file exists and is a regular file.

     -d file     true if file exists and is a directory.

     -h file     true if file exists and is a symbolic link.

     -c file     true if file exists and is a character special file.

     -b file     true if file exists and is a block special file.

     -p file     true if file exists and is a named pipe (fifo).
     -u file     true if file exists and its set-user-ID bit is set.

     -g file     true if file exists and its set-group-ID bit is set.

     -k file     true if file exists and its sticky bit is set.

     -s file     true if file exists and has a size greater than zero.

     -t [ fildes ]
		 true if the open file whose file descriptor number is
		 fildes (1 by default) is associated with a terminal
		 device.
     -z s1       true if the length of string s1 is zero.

     -n s1       true if the length of the string s1 is non-zero.

     s1 = s2     true if strings s1 and s2 are identical.

     s1 != s2    true if strings s1 and s2 are not identical.

     s1          true if s1 is not the null string.

     n1 -eq n2   true if the integers n1 and n2 are algebraically equal.
		 Any of the comparisons -ne, -gt, -ge, -lt, and -le may
		 be used in place of -eq.

     -L file     true if file exists and is a symbolic link.

     These primaries may be combined with the following operators:

     !           unary negation operator.
     -a          binary and operator.

     -o          binary or operator (-a has higher precedence than -o).

     ( expr )    parentheses for grouping.  Notice also that parentheses
		 are meaningful to the shell and, therefore, must be
		 quoted.

SEE ALSO
     find(1), sh(1).

WARNING
     If you test a file you own (the -r, -w, or -x tests), but the
     permission tested does not have the owner bit set, a non-zero
     (false) exit status will be returned even though the file may have
     the group or other bit set for that permission.  The correct exit
     status will be set if you are super-user.

     The = and != operators have a higher precedence than the -r
     through -n operators, and = and != always expect arguments;
     therefore, = and != cannot be used with the -r through -n
     operators.

     If more than one argument follows the -r through -n operators,
     only the The = and != operators have a higher precedence than the
     -r through -n operators, and = and != always expect arguments;
     therefore, = and != cannot be used with the -r through -n
     operators.

     If more than one argument follows the -r through -n operators,
     only the first argument is examined; the others are ignored,
     unless a -a or a -o is the second argument.

Case/Switch constructs

---------------------------------------------

case word in
   pattern1) command(s)
   ;;
   pattern2) command(s)
   ;;
esac

---------------------------------------------

For loops

----------------------------------------------
                                                
for var in values
do
   command(s)
done
                                                
----------------------------------------------

While loops

------------------------------------------
                                            
while command(s)
do
   command(s)
done                                        
                                            
------------------------------------------

Until/goto

------------------------------------------
                                            
until command(s)
do
   command(s)
done
                                            
------------------------------------------

The break and continue commands alter loop control flow.

csh example (can be done at command line)

cd /home

foreach u (*)

  if ( ! -f $u/.login ) then

    echo $u has no .login file

  endif

end

Special shell variables

Bourne shell parameter-substitution expressions
There are two types of parameters commonly introduced with the dollar-sign '$', that of positional and keyword.

------------------------------------------
                                            
$#	The number of positional parameters, base 10.
$0	Positional parameter zero; the command or name of the script,
	itself.
$1      The first of the parameter following the name of the script
	invoked.
$*      All positional parameter starting with $1. Separated by
	spaces.
$@      All positional parameter starting with $1. Separated by
	spaces yet expanded within double-quotes.
$-      Flast supplied to the shell on invocation or by the set
	command.
$?      Decimal status value of the last synchronously executed
	command.
$$	Reports the process-id of the parent shell.
$!	Process-id of the last background command invoked.
                                            
------------------------------------------

Redirection

------------------------------------------
                                            
The file descriptors are 0, 1 and 2 for standard in, out and error.

<filename	filename provides standard input
>filename	filename created or overwritten with standard output.
>>filename	filename is appended-to with standard output.
<digit		associate file descriptor digit with standard
		input.  note that 0<&digit is the same thing.
>&digit		associate file descriptor digit with standard
		output.  note that 1>&digit is the same thing.
		2>&1 is commonly used to associate standard error
		with standard output, so that all errors go to the
		standard output device.
|		your basic pipe.

Precidence is left-to-right. Thus 1>xxx 2>&1 assocates 1 with
xxx and 2 with xxx, as well.

------------------------------------------