Shell scripts

  A shell script is just a collection of shell commands that are stored
  in a file.  For example, put the following into a file "foo":

    who | sort

  By typing "sh foo", you will run the commands in the file foo.

  Unfortunately, most of what we do with the shell is "shell specific".
  That means that it will vary from shell to shell.  We will be using
  Bourne shell, but many people use C-shell instead.  As an example of
  the differences between shells, here is how you do variable assignments
  in Bourne shell and C-shell:

  Bourne shell:  foo="hello world"
  C-shell:       set foo="hello world"

  Because the syntax is different from shell to shell, you must be careful
  that you use the right shell to run your scripts.  This means that if
  you are going to experiment interactively with shell scripting, you
  should first start an interactive Bourne shell: type "sh".

  Input and output:

    UNIX shells use "|", "<", ">", ">>", and "<<" to describe operations
    on the output and input for commands.

    |  The vertical bar (called a "pipe") is used to take the output from
       one command and turn it into the input for the second command.  Try
       the following:

       who | sort  # try this on harper

       "who" lists some statistics about the current users of the machine
       (output).  "sort" reads that output and sorts it.  The pipe binds
       their input and output together.

    >  The greater than symbol is used to put the output from a command
       into a file.  For example:

       who | sort >some_file

       stores the output from the "who | sort" in the file "some_file".
 
    <  The less than symbol is used to take input from a file.  For example
       "who | sort > some_file" could be broken down into the following
       sequence of commands:

         who >temp_file
         sort <temp_file >some_file
         rm temp_file

    >> The double greater than symbol is quite similar to the single greater
       than symbol.  The only difference is that if the output file already
       exists, then the output from the current command is appended to it
       rather than having the file "truncated" and then having its contents
       replaced.

    << The double less than symbol is quite different from the rest.  Its
       use is primarily for shell scripts (which we will get to soon), but
       it can be experimented with from the shell.  It is called "heredoc".
       An example of its use is:

         cat <<END_OF_EXAMPLE | sort
         a
         c
         b
         END_OF_EXAMPLE

  Regular Expressions:

    The shell provides a system of "wildcards" which can be used to
    select a set of files (or other things [see below]) through regular
    expressions.

    As an example, to list all of the files that start with f, a user
    might do:  "ls f*" the "*" expands to match all file endings.

    The main shell regular expressions:

      *     - Matches any number of any character
      ?     - Matches one of any character
      [a-t] - Matches any one of the letters between a and t

    Other applications use a different method to describe regular
    expressions.  The application "grep" (which can be used to search
    files for occurrences of a regular expression) uses the following:

      .     - Matches one of any character
      [a-t] - Matches any one of the letters between a and t
      *     - Matches any number of the preceding regular expression
      ^     - Matches the beginning of the line
      $     - Matches the end of the line

    These can be used together to create a simple and precise description
    of text.  For example:

      grep '^Derek.*foo$' file

    will print every line in "file" that starts with "Derek" and
    ends with "foo".

  Variables:

    There are two types of variable in Bourne shell: local and environment.
    Local variables can only be used in the shell that created them, and
    environment variables can be used by any process that is started from
    the shell they were created in.  Both are created the same way:

     var_name="variable value"

    and both are used the same way (with $var_name), but environment
    variables are "exported" with the export command:

     export var_name

    As an example, lets look at the command "echo".  echo just prints the
    text it was given to print (for example "echo hello world").  Lets
    put an echo into a file "sub_script":

      echo $variable

    and then make a separate script ("main_script") to run it:

      variable="This is variables value"
      sh sub_script

    When we run "main_script", we see that it doesn't print anything.
    If we export "variable", sub_script will be able to use it:

      variable="This is variables value"
      export variable
      sh sub_script

    Try it out on your own.

    To print the environment variables of the current shell, type "env".

    PATH:

      The path is one of the most import variables of the shell.  If it
      is misset, almost nothing will work.  The path lists a set of
      directories that are searched (in order) for commands that the
      shell wants to run.  For example, the command "ls" is situated
      in /bin/ls.  If your path contains the directory "." then that
      means that commands can be in your current directory.  We can
      exploit this by making our shell scripts into commands that we
      can use just like they were "ls".

      To do this, we do the following:

        Add "#! /bin/sh" to the first line --- this tells the operating
        system that the shell script is to be run using "/bin/sh".

        Make sure the file is readable and executable (chmod u+rx file).

      In the end, we will have something like this:

        #! /bin/sh
        var="This is variables value"
        export var
        sh sub_script

      After we put it into a directory in our path (which could just be
      the current directory if "." is in our path), we can run it just by
      typing "main_script".  To add a directory to your path, just
      augment the PATH setting:

        PATH=".:$PATH"

      or:

        PATH="$PATH:."

    HOME:

      The environment variable HOME points to the users "home directory".
      This directory differs from the others in that when "cd" is used
      without any arguments, the users shell returns to the home directory.

      Most shells provide a way of describing the home directory with
      a tilde (~).  For example, ~/foo is the file foo in your home
      directory, and ~joe/foo is the file foo in the user "joe"s home
      directory.

    Quoting:

      There are 3 types of quotes that we use: single ('), double ("),
      and back (`).  Single quotes prevent the shell from expanding
      anything inside of them (for example echo '$PATH') will not tell
      you the value of your path variable.  Double quotes do allow
      expansion of variables (echo "$PATH"), and back quotes are something
      different altogether.  Back quotes are used for putting the
      output from a command into a variable.  For example foo=`who`
      will store the output from "who" in the variable foo.

  Return values:

    Besides producing output, etc, commands have a return value.
    This return value is set with the "exit" command.  In Bourne
    shell, the return value of the last process is stored in the
    special variable "$?".  Processes typically indicate whether
    they failed or succeeded by returning zero (success) or something
    else (failure).  If your script does not use the "exit" command,
    a return value of 0 is assumed.

    The command "test" can be used to do a variety of tasks including
    checking to see if files or directories exist, and comparing
    variable values.  It never prints anything --- instead its return
    value is used.  See examples later.

  Flow control:

    If statements:

      The form of an if statement is as follows:

        if command1
        then
          command_set1
        elif command2
        then
          command_set2
        else
          command_set3
        fi

      When the return value of "command1" is 0, command_set1 is run,
      else if the return value of "command2" is 0, command_set2 is run,
      otherwise command_set3 is run.  The elif and else parts are
      optional.

      For example:

        if test -d /
        then
          ls /
        else
          echo 'There is no root directory !?!'
        fi

    For statements:

      The form of a for statement is as follows:

        for arg in arg_list
        do
          command_set
        done

      For example:

        for i in 1 2 3 4
        do
          echo $i
        done

    While statements:

      The form of a while statement is as follows:

        while command
        do
          command_set
        done

      where command_set is run while command continues to return 0.
      For example:

        while test -d /
        do
          echo "There is a root directory"
        done

    Case statements:

      The form of a case statement is as follows:

        case string
        in
           re1) command_set1
                ;;
           re2) command_set2
                ;;
        esac

      where command_set1 is run if string matches shell regular
      expression re1, and command_set2 is run if string matches
      shell regular expression re2.  For example:

        case "$foo"
        in
          Derek*) echo "$foo begins with 'Derek'"
                    ;;
          *)        echo "$foo does not begin with 'Derek'"
                    ;;
        esac

    Functions:

      The form of a function is as follows:

        function_name () {
          command_set
        }

      whenever function_name is used, command_set will be run.

  Miscellany:

    Special variables:

      Like $? (return value of last process) there are a number of
      special variables that are set when a script is running.
      Among the most important are $#, $*, $@, and $0 - $9.
      These variables are used to manipulate the arguments to the
      shell script.  For example:

      #! /bin/sh

      echo "There are $# arguments to $0"
      for var in $*
      do
        echo $var
      done
      echo "The first argument was $1"      

Notes:

  For a complete description of shell scripting, please read the excellent
  text "UNIX Shell Programming" by Kochan and Wood.