LINUX System : Lecture 6

Shell Programming

Acknowledgement: Prof. McCourt lecture notes

Extension of Functionality
 UNIX is designed so that users can extend
the functionality
 To build new tools easily and efficiently
 To customize the shell and user interface.
 To string together a series of Unix commands
to create new functionality.
 To create custom commands that do exactly
what we want.
Shell
 Command Interpreter that turns text that
you type (at the command line) into
actions
 User Interface: take the command from
user

 Shell Programming
 We often want to do a number of commands together
 And bundle them up into one new command.
 Just like a batch file in MS-DOS
Shell scripts

 Any collection of shell commands can be

stored in a file called a shell script.

 Scripts have variables and flow control

statements like other programming languages.
Popular Shells
 sh Bourne Shell
 ksh Korn Shell
 bash Bourne-Again Shell
 Most common shell in Linux
 Default for most Linux machines and OSX
 Developed by GNU project
 csh,tcsh C Shell : similar to C language
 Default for BSD-based systems
 Shell scripts among those shells are slightly
different
shell script
 Creating a simple shell script
 A shell script is a file that contains commands that the shell
can execute.
 Any commands you enter in response to a shell prompt.
 A utility
 A compiled program
 Another shell script
 Control flow commands
 Run a shell script
 Enter the script filename on the command line
 The shell interprets and execute the commands one after
another
 Why shell script?
 Simply and quickly initiate a complex series of tasks or a
repetitive procedure.
Shell script example
#!/bin/csh

echo “Current Time - `date`”

echo I am `whoami`

C Shell
Invoking scripts

There are two ways to launch scripts:

1) Direct interpretation
csh scriptfile [args …]
2) Indirect interpretation
The first line of the file must be
#!/bin/csh
and the file must be executable (permission).

C Shell
Shell Variables
 Environment Variables
 Used to provide information to programs

 (Global) environment variable

 New programs and shells inherit
environment variables from their parent shell
 (Local) shell variable
 Used only by that shell
 Not passed to other processes
Environment Variables
 “env” or “printenv” command
 Display current environment variables
 DISPLAY The graphical display to use, e.g. nyssa:0.0
 EDITOR The path to your default editor, e.g. /usr/bin/vi
 GROUP Your login group, e.g. staff
 HOME Path to your home directory, e.g. /home/frank
 HOST The hostname of your system, e.g. nyssa
 IFS Internal field separators, usually any white space (defaults to tab,
space and <newline>)
 LOGNAME The name you login with, e.g. frank
 PATH Paths to be searched for commands, e.g.
/usr/bin:/usr/ucb:/usr/local/bin
 PS1 The primary prompt string, Bourne shell only (defaults to $)
 PS2 The secondary prompt string, Bourne shell only (defaults to >)
 SHELL The login shell you're using, e.g. /usr/bin/csh
 TERM Your terminal type, e.g. xterm
 USER Your username, e.g. frank
Set Shell Variables
 Mostly set automatically when log in

 setenv
 $ setenv NAME value # in C Shell

 set
 $ set name = value # in C Shell
Variables

To set variables:
set X [= value] # processed as a string

To unset variables : unset X

Variable contents are accessed using ‘$’:

echo $PATH

C Shell
Array
To create lists:
set Y = (abc 1 123)

To set a list element:

set Y[2] = 3

To view a list element:

echo $Y[2]

To count the number of variable elements:

echo $#Y

set fname = prog1

rm ${fname}.c

C Shell
Built-in Variables
$user -- who am I?
$path -- my execution path (list of directories to be searched
for executables)
$term -- what kind of terminal I am using
$status -- a numeric variable, usually used to retun error
codes
$prompt -- what I am currently using for a prompt
$shell -- which shell am I using (usu. either /bin/csh or
/bin/sh)

% set
Will display the variable lists.
Arithmetic (@) command
 C shell provides arithmetic operators
 must be used with the arithmetic (@)
command
 Arithmetic command works only with
integers.

set count = 5
@ count += 2
echo $count
7
Shell Arithmetic
 expr op1 math-operator op2

 Example
% expr 1 + 3
% expr 10 \* 3
% set A = `expr 3 + $B`
Command arguments
A shell script to swap files:
#! /bin/csh
set tmp = $argv[1]
cp $argv[1] tmp_file
cp $argv[2] $argv[1]
cp tmp_file $argv[2]

Arguments : $argv
The number of arguments to a script: $#argv

C Shell
if-then-else

if ( expr ) simple-command

if ( expr ) then
commandlist-1
[else
commandlist-2]
endif

C Shell
if-then-else exampe

#! /bin/csh
if ($#argv != 2) then
echo "we need two parameters!"
else
set tmp = $argv[1]
cp $argv[1] tmp_file
cp $argv[2] $argv[1]
cp tmp_file $argv[2]
endif
C Shell
Loops

while ( expr )
commandlist
end

foreach var ( worddlist )

commandlist
end

C Shell
switch

switch ( str )
case string1:
commandlist1
breaksw
case string2:
commandlist2
breaksw
default
commandlist
endsw

C Shell
goto (Considered harmful!)

To jump unconditionally:
goto label

A label is a line such as:

label:

The classic paper on why not to use goto:

Go To Statement Considered Harmful
Edsger W. Dijkstra, CACM, March 1968

C Shell
shift command
 Moves the values in the parameters
toward the beginning of the parameter
list
#!/bin/csh –f

echo “There are” $#argv “parameters\n”

while ($#argv > 0)

echo –n “$argv[1] “
shift
end

echo “\n”
echo “There are now” $#argv “parameters”
echo “end of script”

C Shell
Input
 Reading Line by Line

% set x = $<
This is a line.
% echo $x
This is a line.
File Operators
-e file : True if file exists
-r file : True if file 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
-o file : True if the user owns it
-f file : True if the file exists and is a regular file
-d file : True if the file exists and is a directory
-s file : True if file exists and has a size greater than zero
-z file : True if file length is zero (empty)
Logical operator
 ! : NEGATE
 && : logical AND
 || : logical OR

 Ex)
if (! -e somefile) then
# does not exist
Debugging
%csh –vx somescript args

-v : vervose
-x : echoes the commands after all substitutions are
made
-n : syntax check. No execution
example
#!/bin/csh
if (-e $argv[1]) then
echo $argv[1] exists
else
echo $argv[1] does not exist and cannot be opened
endif
# rest of script here

C Shell
example
#!/bin/csh

set sum = 0

echo –n “Enter a number: ”

set num = $<

while ($num != “”)

@ sum += $num
echo –n “Enter the next number: ”
set num = $<
end

echo “\nThe sum of the number is : $sum”

C Shell
Guidelines
 Shell script is better than C program if the problem
can be solved by using UNIX commands

 Why script?
 Easier to create and modify
 Easy to debug

 Good thing to do
 Use redirection and pipe
 Do validity check (argument number , type)
 Check existence of files and directories
 Display error messages
example
#!/bin/csh

set j = (1 2 3 4 5)
foreach i ($j)
echo $i Hello
end

C Shell
example
#!/bin/csh

set ary = `cat ary.dat`

echo “The whole array : $ary”

echo “The number of elements : $#ary”
echo “The first element: $ary[1]”
echo “The last element: $ary[$#ary]”

C Shell
Numeric validation
example
#!/bin/csh

echo $argv[2] > temp

grep ‘^[0-9]*$’ temp > /dev/null

if ($status != 0) then
echo “Month argument is not numeric”
exit 1
endif

if ($argv[2] < 1 || $argv[2] > 12) then

echo “Month argument must be <1…12>”
exit 2
endif
echo “Validation is OK. We continue.”

C Shell
example
#! /bin/csh -f
foreach name ($argv)
if ( -f $name ) then
echo -n "delete the file '${name}' (y/n/q)?"
else
echo -n "delete the entire dir '${name}' (y/n/q)? "
endif
set ans = $< # $< means “read a line”
switch ($ans)
case n:
continue
case q:
exit
case y:
rm -rf $name
continue
endsw
end

C Shell
Exercise 1

 Write a shell script that displays the

number of files and directories in a given
directory

 format
% ./fd_count.csh directory_name
Exercise 2
 Write a shell script that removes
duplicate words from an input text file.

 Format
 % remove_dup.csh in.txt out.txt
Four
Two
One Four Two One Three
One out.txt
Four
Two
in.txt
Two
Three
Bash Shell
• Shell beginning
#!/bin/bash
# This is the beginning of a shell script

• Setting Variables
> MYVAR=“a new variable”
> echo $MYVAR
A new variable

> x=3
> echo $x
3
> export seven=7
> echo $seven
7
Command Output
 In order to use the output of a command within
our script, we must set it apart using backticks
 `command`
 Or $(command)

#!/bin/bash
echo date
echo `date`
echo $(date)
Test
 To test an expression, use one of
these :
 test EXPRESSION
 [EXPRESSION]
 Returns 0 if true, 1 if false
File Tests
Control Structures
 Example
#! /bin/bash
if [ $? -eq 0 ]
then echo "Last command exited cleanly!"
fi

#! /bin/bash
if [ $? -eq 0 ]
then echo "Last command exited cleanly!"
else echo "Uh-oh - non-zero exit status!"
fi
Arguments
 $1, $2, $3, etc.
 each argument passed to our script is
assigned a variable
 $0
 stores the name of the script
 $#
 gives us the number of arguments
#! /bin/bash
if [ ! $# -eq 3 ]
then echo "Correct usage: $0 arg1 arg2 arg3"
exit
fi
Arithmetics
Arithmetics
 Let built-in
let VAR=$1+15

 $[expression]
echo $[ 323*17 ]
Arrays
 declare -a arrayname
 arrayname[index_number]=value
 arrayname=(value1 value2 ... valueN)

 Accessing Array Element

 ${arrayname[index]}
> array=(’Cornell University’ CS2042 ’Intro to Unix’)
> echo ${array[2]}
Intro to Unix
Multiple Options
#! /bin/bash
# This script prints the # of days in the month.
MONTH=$(date +%b)
case $MONTH in
Jan|Mar|May|Jul|Aug|Oct|Dec)
NUMDAYS=31;;
Apr|Jun|Sep|Nov)
NUMDAYS=30;;
Feb) NUMDAYS=28;;
esac
echo “This month of $MONTH has $NUMDAYS days.”
exit
while loop
 while condition; do command-list; done
 Executes command-list until ’condition’ no longer returns true
 When ’condition’ fails, the script continues with the command
following ’done’
 ’condition’ can be any expression or command that returns a
status
for loop
 for name in word; do list; done
 Expands word into a list of items
 Replaces name with each item as it performs list

 Example1
#! /bin/bash
for FILE in `ls *.txt`; do cp $FILE $FILE.bak; done
function
 Shell functions are a way to group
commands together for later execution,
using a single name for the group.

 Function syntax
 function name { commands; }
 name() { commands; }
Local/Global Variables
 Example
#! /bin/bash
VAR=”global variable”
function func {
local VAR=”local variable”
echo $VAR; }
# Execute our new function!
func
echo $VAR
Function Parameters
 Example
#! /bin/bash
function function_A {
echo $1; }
function_A “A function parameter!”
echo $1