Introduction to Unix Shell

&
Scripting with csh/tcsh
Brief Unix History
Unix Shell & Flavor
CSH/TCSH Scripts

Unix Family Tree

Unix Architecture

Unix History and Motivation

The first version of Unix came from AT&T in the

early 1970s (Unix is old!).
Unix was developed by programmers and for
programmers.
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.

What is Shell?
Shell is

Command Interpreter that turns text that you

type (at the command line) in to actions:
User Interface: take the command from user

Programming Shell can do

Customization of a Unix session

Scripting

Customization of a Session
Each shell supports some customization.

User prompt
Where to find mail
Shortcuts (alias)

The customization takes place in

files

startup

Startup files are read by the shell when it

starts up
The Startup files can differ for different shell

Types of Shells
Interactive vs. Non-interactive; login or not
Interactive login shell started after login
Non-interactive shell

Present when shell script is running

Just inherits parents environment

Interactive non-login shell started

Started from a command line

Copies parent environment then invokes
~/.bash_rc (or ~/.cshrc or ~/.tcshrc)

Popular Shells
sh
ksh
csh,tcsh
bash

Bourne Shell
Korn Shell
C Shell (for this course)
Bourne-Again Shell

Families of Shells

Flavors of Unix Shells

Two main flavors of Unix Shells

Bourne (or Standard Shell): sh, ksh, bash, zsh

Fast
$ for command prompt

C shell : csh, tcsh

better for user customization and scripting
%, > for command prompt

To check shell:

% echo $SHELL (shell is a pre-defined variable)

To switch shell:

% exec shellname (e.g., % exec bash)

Startup files

sh,ksh:
/etc/profile
(out-of-the-box login shell settings)
/etc/profile.local (addtnl. local system settings)
~/.profile
(addtnl. user customized settings)
~/.kcshrc (non-login shell user customization)
bash:
/etc/profile (out-of-the-box login shell settings)
/etc/bash.bashrc (out-of-box non-login settings)
/etc/bash.bashrc.local (global non-login settings)
~/.bash_profile
(login shell user customization)
~/.bashrc (non-login shell user customization)
~/.bash_logout (user exits from interactive login shell)
csh/tcsh:
/etc/login (out-of-the-box login shell settings)
/etc/csh.login (non-login shell customizations)
/etc/csh.login.local (global non-login settings)
~/.login: (login shell user customizations)
~/.cshrc: (non-login shell user customizations)
~/.cshrc.logout: (non-login shells at logout)
~/.logout: (read by login shells at logout)

Some Special Keys Under tcsh

Ctrl-U = Delete everything on the commandline
Ctrl-A = Move cursor to the front
Ctrl-E = Move cursor to the end
Ctrl-P = Set the current command-line to the
previous command
Ctrl-N = Set the current command-line to the
next command
TAB = Filename completion

Dont forget your Best Friend

% man command (e.g., % man ls)

shows information about the command

usually space or Enter for more information
q to quit
% man man

Create a 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 programming

Make the file executable

When you create a shell script using a editor,

does it have execute permission typically?
Example:
script!...)

(Make sure you are using tcsh/csh

willow> echo $SHELL

/bin/tcsh
willow> ./test
./test: Permission denied.
willow> ls -l test
-rw-r--r-- 1 student ums
willow> chmod +x test
willow> ./test
This is Test!

33 Sep 18 16:33 test

Invoking a Shell script

Give the shell a command on the command line

The shell forks a process

Which creates a non-interactive duplicate of the shell process

The newly forked process attempts to exec the command

If the command is an executable program

Exec succeeds
System overlays the newly created subshell with the executable
program
The command is a shell script
Exec failed
The command is assumed to be a shell script
The subshell runs the commands in the shell.

Invoking a Shell script

The shell itself is program

It can be run as a command in a shell and

also accepts arguments. Note: Lets find your
default shell executing echo $SHELL
willow> echo $SHELL
/bin/tcsh

To run a shell script

Which does not have executable permission

Ex: willow>tcsh test

Run the script with different shell other than

your interactive shell
Ex: willow>sh test

Invoking a Shell script

Put special characters on the first line of a shell script

To tell OS checks what kind of file it is before attempting to

exec it
To tell which utility to use (sh, csh, tcsh, )

Special sequence

The firsts two character of a script are #!

Then followed by the absolute pathname of the program that
should execute the script
Ex:
willow> more test
#!/bin/tcsh
# This line will not run since it is commented out...
echo 'This is Test!

Make a comment #
Comments make shell scripts easier to

read and maintain

Pound sign (#) start a comment line until
the end of that line as second line in
previous example, except

#! In the first line.

Or inside quotes

Parameters and Variables

A shell parameter is associated with a value that is

accessible to the user.

Shell variables

Names consist of letters, digits and underscores

By convention, environment variables use UPPERCASE

User created variables (create and assign value)
Keyword shell variables

Have special meaning to the shell

Being created and initialized by the startup file

Positional parameters

Allow you to access command line arguments

Special parameters

Such as

The name of last command

The status of most recently executed command

The number of command-line arguments

Positional Parameters
The command name and arguments are the

positional parameters.

Because you can reference them by their position on

the command line
$0 : Name of the calling program
$1 - $9 : Command-line Arguments

The first argument is represented by $1

The second argument is represented by $2
And so on up to $9
The rest of arguments have to be shifted to be able to use
$1- $9 parameters.

Positional Parameters
Example:
Change

directory to your assigned numbered subdirectory

willow> cd 1
List

the directory contents, confirming display_5args

willow> ls -l display_5args
Change

mode of display_5args to executable

willow> chmod +x display_5args

Execute

the script

willow> ./display_5args 1 2 3 4 5
you are running script ./display_5args with parameter 1 2 3 4 5

Positional Parameters

$1-$9 allows you to access 10 arguments

How to access others?

Promote command-line arguments: shift

Built-in command shift promotes each of the

command-line arguments.

The first argument ( which was $1) is discarded

The second argument ( which was $2) becomes $1
The third becomes the second
And so on

Makes additional arguments available

Repeatedly using shift is a convenient way to loop
over all the command-line arguments

Positional Parameters

Example:

willow> more demo_shift

#!/bin/tcsh
echo $1 $2 $3
shift
echo $1 $2
shift
echo $1
willow> ./demo_shift 1 2 3
123
23
3

willow> more demo_shift

#!/bin/tcsh
echo $1 $2 $3
shift
echo $1 $2
shift
echo $1
shift
echo $?
shift
echo $?
shift
echo $?
willow> ./demo_shift 1 2 3 4
1 2 3
2 3
3
0
0
shift: No more words.

Special Parameters

Useful values

Command-line arguments
Execution of shell commands
Can not change the value directly, like positional parameters

Value of Command-line arguments: $* and $@

$* and $@represent all the command_line arguments ( not just

the first nine)
$* : treats the entire list of arguments as a single argument
$@ : produce a list of separate arguments (Only bash/ksh/sh)

BASH SCRIPT WITH $*and $@

TCSH SCRIPT WITH $*and $@

willow> more for_test.bash

#!/bin/bash

willow> more for_test

#!/bin/tcsh

echo "using \$* "

for arg in "$*"
do
echo "$arg"
done
echo "using \$@ "
for arg in "$@"
do
echo "$arg"
done
willow> ./for_test.bash 1 2 3
using $*
123
using $@
1
2
3

echo 'using $*'

foreach arg ($*)
echo "$arg"
end
echo 'using $@'
foreach arg ($@)
echo "$arg"
end
willow> ./for_test 1 2 3
using $*
1
2
3
using $@
Illegal variable name.

Special Parameters
The number of arguments: $#

Return a decimal number

Use the test to perform logical test on this
number

willow> more num_args

willow> ./num_args 1

echo this script is called with $#

arguments.

this script is called with 1 arguments.

willow> chmod +x num_args

willow> ./num_args
this script is called with 0 arguments.

willow> ./num_args 2
this script is called with 1 arguments.
willow> ./num_args 0
this script is called with 1 arguments.

Special Parameters

Exit status: $?

When a process stops executing for any reason, it

returns an exit status to its parent process.
By convention,
Nonzero represents a false value that the command
failed.
A zero value is true and means that the command was
successful

You can specify the exit status that a shell script

returns by using the exit built-in followed by a
number

Otherwise, the exit status of the script is the exit status

of the last command the script ran.

willow> ls a
a: No such file or directory
willow> echo $?
2
willow> echo olemiss
olemiss
willow> echo $?
0

willow> more exit_status

echo this program will have the exit code of 8.
exit 8
willow> ./exit_status
this program will have the exit code of 8.
willow> echo $?
8
willow> echo $?
0

Summary
A shell is both a command interpreter and a programming
language.
Job control

Variables

Control-z/fg/bg/&
Local and environment variables
Declare and initialize a variable ( no type)
Export unset

Command line expansion

Parameter expansion/variable
expansion/command/substitution/pathname expansion
Quote ( \ )
all but parameter, variable expansion and \
suppress all types of expansion
\ escaping the following special character

Basic Script Example

willow> more basic_script
#!/bin/tcsh
echo 'Listing the files in long format appending due date/time'
echo
ls -lrtah
echo
echo 'Listing the files in long format appending due date/time'
echo
df -k
# Using diff to find two files differences and writing them to another file
diff -c for_test.bash for_test >> file_differences &
echo
echo 'sleeping mode for 4 seconds. Please wait!'
echo
sleep 4
echo
echo 'GO REBELS'
echo 'To find out the differences of files for_test and for_test.bash, '
echo 'Please open file_differences via using cat command as shown below:'
echo 'cat file_differences

Killing BAD Processes

The kill command:

kill [-<signal>] <pid>
Send <signal> to process <pid>

The killall command:

killall [-<signal>] <command>

Send <signal> to all processes that start with
<command>

Useful signals (kill l for the complete list):

TERM
KILL
HUP
STOP

the default, terminate, kills things nicely

will kill anything, but not nicely
hangup, used to reload configurations
stops (suspends) a running process

Summary

Shell parameters

HOME
PATH
PS1
SHELL
$0
$n
$*
$@
$#
$$
$!
$?

Summary
Special Characters

NEWLINE
;
()
&
|
>
>>
<
<<

*
?
\

` `
[]
$
.
#
&&
||
!