Introduction to csh

Why use csh scripts?

The basic idea of scripting with the shell is that you have a set of commands, and perhaps some control statements, which make the shell do a series of commands. Basically there is no difference between a script and a program.

In particular, csh can be good for writing short scripts to run test sequences. The following quote motivates using scripts in this way [2]:

It's tedious and unreliable to do much testing by hand; proper testing involves lots of tests, lots of inputs, and lots of comparisons of outputs. Testing should therefore by done by programs, which don't get tired or careless. It's worth taking the time to write a script or trivial program that encapsulates all the tests, so a complete test suite can be run by (literally or figuratively) pushing a single button. The easier a test suite is to run, the more often you'll run it and the less likely you'll skip it when time is short.

How to invoke a csh script?

There are three ways:

1. Execute csh directly and then enter script commands interactively.

2. Store a group of csh commands in the file 'myScript' and execute it using:

   % csh myScript ...
   

   where '...' is replaced by a sequence of arguments. The shell places these arguments in the variable argv and then begins to read commands from the script.

3. Begin the script with the line

   #!/usr/bin/csh ...
   

   where '...' is again the arguments to the shell. The only argument we will mention here is -f which stops the shell script from sourcing your ~/.cshrc.

   You can then execute the file directly, assuming it has been granted "execute" permissons.

Comments

• Comments are anything on a line following '#'. For example:

  # This line does nothing 
   
  /usr/local/bin/ls   # This line runs ls, but this is a comment 
  

Variables

• You can use variables in csh for:
  1. Getting environment information
  2. Storing user-defined information (ie. set MY_EDITOR /usr/local/bin/emacs)
  3. Getting command output with backticks (ie. set DATE = 'date')

• Variable Substitution is done on words preceded by '$'. This subsitution replaces the names of variables by their values. For example:

  #!/usr/bin/csh
  echo "Your display is $DISPLAY"
  

• The notation

  $?name
  

  expands to `1' if name is set, or to `0' if name is not set. It is the fundamental mechanism used for checking whether particular variables have been assigned values. All other forms of reference to undefined variables cause errors.

• The notation

  $arrayName[n]
  

  gives access to the nth component of the variable 'arrayName'

• The notation

  $#arrayName
  

  expands to the number of elements in the variable name.

• Example:

  joe@cab104:~> csh
  % set myArray = (a b c)
  % echo $?myArray
  1
  % echo $#myArray
  3
  % echo $myArray[2]
  b
  % unset myArray
  % echo $?myArray
  0
  % echo $myArray
  Undefined variable: myArray.
  %
  

Command Line Arguments

• Command line arguments are passed into your shell script as special variables. There are two ways to address these variables, and thus grab command line args:
  1. Use the variables $n. For example, $1 is the first argument, $2 is the second parameter. You can use these variables as you would any other string, eg, as arguments to commands and the like.
  2. Use the special array $argv. You can grab an argument as a member of this array, eg, $argv[n] is the nth argument. As well you can address $#argv, the total number of arguments.

• For example:

      #!/usr/bin/csh
  
      echo "You entered $#argv arguments"
      echo "1st one= $1"       # method 1
      echo "2nd one= $argv[2]" # method 2
  

  And the output looks:

      justin@cab104:~>./myScript hi there
      You entered 2 arguments
      1st one= hi
      2nd one= there
  

Control Flow

• Conditional execution:

      if (expr) then 
          commands
      else if (expr) then
          commands
      else 
          commands
      endif
  

• Conditional repetition of commands:

      while (expr)
          commands
      end
  

• Definite repetition of commands with an index variable, vrbl, that takes on successive values from list

      foreach vrbl (list)
          commands
      end
  

• Selection among groups of commands according to the results of successively matching string against case label patterns

      switch (string)
      case pattern:
           commands
           breaksw
      case pattern:
           .
           .
      default:
          commands
      endsw
  

• Repeatedly execute command count times. The command must be simple.

      repeat count command
  

• Example:

      #!/usr/bin/csh
  
      repeat 2 echo Greetings!
  
      echo
      foreach i (1 3 five)
          echo "i = [$i]"
      end
  
      echo
      set BEST_EDITOR = "emacs"
      switch ($EDITOR)
  
          case $BEST_EDITOR:
              echo "You are cool"
              breaksw
          default :
              echo "You are not as cool as an emacs user"
          breaksw
      endsw
  

  And the output looks like:

      justin@cab104:~>./myScript
      Greetings!
      Greetings!
  
      i = [1]
      i = [3]
      i = [five]
  
      You are cool
  

File Enquiries

• csh allows file enquiries of the form

      -? filename
  

  where `?' is replaced by a number of single characters:

  -r file	-- test if file can be read
  -w file	-- test if file can be written to
  -x file	-- test if file can be executed
  -d file	-- test if file is a directory
  -e file	-- test if file exists
  -o file	-- test if you are the owner of file
  -z file	-- test if file is empty
  -f file	-- test if file is an ordinary file, that is, not a direcotry, not a character special, and not a block special file

Tips

• Use absolute pathnames to commands whenever possible. This means that any (user-defined) aliases for the commands will be ignored, making the script more portable. For example, use /usr/local/bin/ls in place of just plain ls

• Use variables to store the absolute pathnames of executables to variables. Then if the executable moves, your script only needs to change in one spot. For example:

  #!/usr/bin/csh
  set LS = /usr/local/bin/ls
  $LS
  

References

1. Basic Scripting with the csh by NCSA
2. "The Practice of Programming", by Brian W. Kernighan and Rob Pike
3. An Introduction to the C shell by William Joy
4. "The Berkeley UNIX Environment" 2nd edition by R. Nigel Horspool