CPS 444/544 Lecture notes: Shell programming

---

Shell scripts

---

• a shell script (or shell program) is a series of UNIX commands placed in an ASCII text file
• each shell (ksh, csh, sh, ...) provides mechanisms for control (e.g., statements like if, while, for, ...)
• UNIX commands (filters) + shell variables + control mechanisms = powerful (interpreted) programming language
• see [UIAN] Chapter 4 (Nutshell) or [PGUS] Chapter 12 (Sobell) for ksh information

---

return vs. exit

---

• same difference as in C, i.e., same meaning in main, different in functions
• return allows you return a value from a function
• exit exits the current shell entirely

---

Command-line arguments

---

• arguments given to a shell script on the command line when it is invoked are available through the variable $* (a space separated list) and "$@" (a list with each argument double quoted separately)
• individual arguments to the shell script are referenced as $1, $2, $3, ..., $9 and $0 is the name of the shell script itself
• $# stores the number of command line arguments (the shell's analog to C's argc minus the command name)
• $# indicates how many arguments were passed
• examples:

     $ echo $* # prints all the command-line arguments
     $ echo $# # the number of command-line arguments (does not include the command name)
     $ echo $0 # prints the command name
     $ echo $1 # prints the first command-line argument
     $ shift n # shifts the arguments left by n, e.g., if n = 1, arg1 = arg2, arg2 = arg3, and so on
  

---

"$*" vs. "$@"

---

• same when unquoted: all arguments on command line, except the command name
• "$*": all arguments on command line as one string ("$1 $2 ...")
• "$@": all arguments on command line, individually quoted ("$1" "$2" ...)

---

for loops

---

• a for loop can be used to iterate over all items in an array or list
• syntax:

     for var [in list]
     do
        statements
     done
  

• if in list is omitted in a for loop in a script, the list is assumed to be $* (all of the command line arguments to the script)
• do and done must be on lines by themselves (or use ; statement separator)
• examples:

     for name in Lucy Linus Lucia Larry Leisel
     do
        print "Next person is $name."
     done
     exit 0
  
     #!/bin/ksh
     #print all arguments to a shell script
     for arg in $*; do
       print $arg
     done
     exit 0
  

---

Illustrative script

---

#!/bin/ksh

echo '$* is ' $*
echo '$@ is ' $@
print '$# is ' $#
print "The number of arguments to $0 was $#."

print $0
print $1
print $2
print $3
print $#

print

#for file
#for file in "$*"
for file in "$@"
do
   echo $file
done

exit 0

$ ./prog "a b" c d
$* is a b c d
$@ is a b c d
$# is 3
The number of arguments to ./prog was 3.
./prog
a b
c 
d
3

a b
c 
d

---

String operators

---

---

Hostname examples

---

HOST=$(hostname | cut -d. -f1)
HOST=$(hostname | awk -F. '{print $1}')
HOST=${HOSTNAME%%.*}

---

String variable comparisons

---

• use within [[ <expression> ]]
• [[ and ]] are each tokens and may only appear with whitespace on each side
• within <expression> you can use parentheses for grouping and the relational operators <, >, <=, >=, ==, !=, &&, and ||
• examples:

     [[ $person = lucy ]]
     [[ $person != linus ]]
     [[ ($person != linus ) && ($person != lucy ) ]]
  

• = is an overloaded operator: assignment and comparison; no space on each side implies assignment; spaces on each side implies comparison
• string variables containing only digits can be treated as numbers
• arithmetic relational operators (for strings representing integers): -lt, -le, -eq, -ge, -gt, -ne

---

if statement

---

• syntax:

     if condition
     then
        statements
     [elif condition
     then
        statements]
     [else
        statements]
     fi
  

• then/else/elif/fi keywords take the place of braces ({}), which mean something special to the shell (RE)
• elif or else can be omitted
• example:

     if [[ $person = steve ]]
     then
         print $person is on the sixth floor.
     elif [[ $person = todd ]]
     then
        print $person is on the fifth floor.
     elif [[ $person = markus ]]
     then
        print $person is on the fifth floor.
     else
        print "Who are you talking about?"
     fi
  

• a condition can be anything which returns an exit status, e.g.,

     options="-f -d -L"
     if print - $options | grep -q -e -d
        then print "option '-d' present in list."
     fi
  

---

Additional condition tests

---

-n <string>	string not null?
-z <string>	string null?
-a <filename>	exists?
-f <filename>	is plain file?
-d <filename>	is directory?
-L <filename>	is symbolic link?
-s <filename>	exists and not empty?
-r <filename>	read permission?
-w <filename>	write permission?
-x <filename>	execute permission?
-O <filename>	your file?
-G <filename>	your group?
<file1> -nt <file2>	file1 newer than file2?
<file1> -ot <file2>	<file1> older than <file2>?



• example:

     if [[ ! -f output.file ]]; then
        print "output.file does not exist."
     fi
  

---

while statements

---

• syntax:

     while condition
     do
         statements
     done
  

• condition has the same syntax as if statements
• can use break or continue or return or exit inside a loop with the same meaning as in C
• example:

     #!/bin/ksh
     # report type of executable file anywhere in search path
      
     path=$PATH
     dir=${path%%:*}
     while [[ -n $path ]]; do
        if [[ -x $dir/$1 && ! -d $dir/$1 ]]; then
           file $dir/$1
           exit 0
        fi
        path=${path#*:}
        dir=${path%%:*}
      done
      print "File not found."
      exit 1
  

---

ourwhich script

---

#!/bin/ksh
   
path=$(echo $PATH | sed 's/:/ /g')
  
# insert code here to catch aliases

cmd=$1
   
for dir in $path; do
   # is it a directory
   # following if is superfluous
   if [[ -d $dir ]];; then
      # is it executable
      if [[ (-x $dir/$cmd) && (! -d $dir/$cmd) ]]; then
         print "$dir/$cmd"
         exit 0
      fi
   fi
done
   
print "$0: no $cmd in ($PATH)"
   
exit 1

• extend to handle more than one command-line argument akin to the which command on our system
• extend to catch aliases akin to the which command on our system
• will have problems with directory names containing a space

---

case selection

---

• syntax:

     case expression in
        pattern1 )
           statements ;;
        pattern2 )
           statements ;;
     .
     .
     .
     esac
  

• double semicolon (;;) is required to terminate statements
• statements corresponding to the first pattern matching the expression are executed, after which the case statement terminates
• expression is usually some variable's value
• patterns can be plain strings, or they can be Korn shell patterns using *, ?, !, [], etc (like file-matching patterns)
• a pattern can consist of several patterns separated by | (logical or), and the pattern can also be written as (pattern)
• attractive for parsing/factoring command-line arguments
• example:

     case $person in
        linus)
           print "Oh..He's on the tenth floor." ;;
        lucy | linda)
           print "They're out to lunch." ;;
        *)
           print "Hmm. Not sure." ;;
  esac
  

• note that inside a case | is does not act as a pipe

---

Factoring arguments

---

#usage -d -f a b c

args=" "$*

echo args:$args:

# investigate the use of getopt and getopts
options=${args%% ([a-zA-Z0-9]|/)*}

options=$(echo $options | sed 's/^[ ]//')

files=${args# $options }

print - options:$options:
print files:$files:

#grep
# -q: quiet; just return exit status
# -e: following is a pattern, not an option; protects patterns with a leading -
# -e is same as -

#if print - $options | grep -q -e -d
#if print - $options | grep -q - -d
#then
#   print - "-d is present"
#   echo "-d is present"
#else
#   print - "-d is absent"
#fi

for option in $options
do
   case $option in
      -d)
         print "found a -d." ;;
      -f | -q)
         print - "-f or -q" ;;
      *)
         print "some other option(s)" ;;
   esac
done

exit 0