Unix Comp-145

Unix Comp-145

LECTURE 8: SHELL PROGRAMMING

BASED ON: S. DAS, “YOUR UNIX: THE ULTIMATE GUIDE”, 2ND EDITION, MCGRAW HILL, 2006

(CHAPTER 13)

BROOKDALE COMMUNITY COLLEGE 111/19/2009 rwj

BROOKDALE COMMUNITY COLLEGE 2

SHELL PROGRAMMING

• PROCESSING FLOW CONTROL IN SHELL SCRIPTS

• LOOP EXECUTION IN SHELL SCRIPTS

• ARITHMETIC COMPARATIVE TESTS IN SHELL SCRIPTS

• DEBUGGING SHELL SCRIPTS

• CONCEPTS IN SHELL PROGRAM DESIGN TECHNIQUES

11/19/2009 rwj


Naming Shell Scripts

• SCRIPT NAME IS ARBITRARY

• CHOOSE NAMES THAT MAKE IT EASY TO QUICKLY IDENTIFY FILE FUNCTION

• USING .SH AS AN EXTENSION TO DENOTE SHELL SCRIPT FILES DOESN'T MAKE THE SCRIPT EXECUTABLE– Example: quartery_report.sh

• USE chmod +x TO MAKE SHELL SCRIPT EXECUTABLE

• TO EXECUTE IN CURRENT DIRECTORY USE./script.sh if script.sh has u=rwx

11/19/2009 rwj

SCRIPTING INTERNALS

• MAKE SCRIPT INTERACTIVE: READ – Enables script to take input from user.

• MAKE SCRIPT NON-INTERACTIVE: PIPES AND REDIRECTION– Use positional parameters– Parameter values input from Command Line when launched– In script input variables referred to a %1, %2, etc

• # INDICATES CHARACTERS TO ITS RIGHT ON THIS LINE IS TO BE IGNORED, I.E., A COMMENT



SCRIPTING INTERNALS

• INTERACTIVE SCRIPT EXAMPLE: $ echo “Enter pattern to be searched: \c” # \c = no newline

$ read var1$ echo “Enter file to be used: \c”$ read var2$ echo “Searching for $var1 from file $var2”$ grep “$var1” $var2

• NON-INTERACTIVE SCRIPT EXAMPLE: $ echo “Program: $0” # $0 always = script name$ echo “The number of arguments specified is $#”$ echo “The arguments are $*” # all arguments stored in $*$ grep “$1” $2$ echo “\nJob Over”


• EXIT STATUS– EXIT - DEFAULT VALUE IS 0– EXIT 0 - TRUE, EVERYTHING OK– EXIT 1 - FALSE, ERROR ENCOUNTERED– $? - STORES EXIT STATUS OF LAST

COMMAND

• WRITER OF SCRIPT DETERMINES SEMANTICS OF SUCCESS– EXAMPLE, NOT FOUND COULD BE EXCEPTION

OR DESIRED RESULT

SCRIPTING INTERNALS

11/19/2009 rwj


• OPERATORS && AND || RECOMMENDED FOR SIMPLE DECISIONS

CMD1 && CMD2 # CMD2 EXECUTED IF CMD1 SUCCEEDS

CMD1 || CMD2 # CMD2 EXECUTED IF CMD1 FAILS

• EXAMPLES:$ grep ‘manager’ foobar || echo “Pattern not found”$ grep “$1” $2 || exit 2 # Quit script if search fails$ echo “Patern found, Job over” #executed only if grep succeeds

SCRIPTING INTERNALS: LOGICAL OPERATORS

11/19/2009 rwj


• If, then, else CONDITIONAL CONSTRUCTS – TESTS COMMAND EXIT STATUS– if REQUIRES A then AND fi ENDING – if ! Command - TEST IS NOT TRUE OR SUCCESSFUL


if command is true # successful?then

excute commandselse

fi


excute commandselse

excute commandsfi


excute commandselif command is true

then excute commands

else excute commands

fi

A.

B.

C.

if command is true; then...

fi

D.

11/19/2009 rwj


• EXAMPLE FROM TEXT


if grep “[: ]$1[: ]” /etc/passwd # successful?then

echo “Pattern found – Job over”else

echo “Pattern not found”fi

$ chmod 744 ifthen.sh$ ifthen.sh Mensing

$ pico ifthen.sh


• USING test AND [ ] TO EVALUATE EXPRESSIONS IN CONDITIONAL CONSTRUCTS – RELATIONAL TESTS

• test RETURNS EXIT STATUS ONLY - USE WITH CONSTRUCTS THAT CAN OPERATE ON AN EXIT STATUS. COMPARE 2 NUMBERS

test $x –gt $y COMPARE 2 STRINGS OR A SINGLE STRING FOR A NULL

VALUEtest $x != $y OR if [!-n “$option”]

CHECK A FILE’S ATTRIBUTESif [-f !-r $1]; then


11/19/2009 rwj


• COMPARE 2 NUMBERS-eq Equal to-ne Not Equal to-gt Greater than-ge Greater or equal to-lt Less than-le Less or equal to

Example:$ x=5; y=7; z=7.4$ test $x –eq $y; echo $?$ 1 -- test returns not true


11/19/2009 rwj


• COMPARE 2 STRINGS= Equal to!= Not Equal to-n string String not NULL-z string String is a NULL stringString String is assigned and not NULL == Strings equal? (only in Korn and Bash Shell)

Example:$ if [“$option” = “y”]; then #tests input equality$ if [-z “$option”]; then #tests input for NULL string



• FILE ATTRIBUTE TESTS -- SEE TABLE 13.4 FOR FULL LIST-f fName fName exist and is a regular file?-r fName fName exist and is readable?-x fName fName exist and is readable?-s fName fName exist and is its size greater than 0?!-s fName fName exist and is its size not greater than 0?

Example:if [-s $1]; then #tests input file exists and size > 0



• USING if AND test IN COMPOUND CONDITIONS – 2 FORMSo USING && AND || TOGETHER WITH OTHER

OPERATORS if [“$0” = “lm”]||[“$0” = “./lm”]; then

o USING -a AND -o TOGETHER WITH OTHER OPERATORS

if [“$0” = “lm”] -o [“$0” = “./lm”]; then



• USING case STATEMENTS (INSTEAD OF IF,THEN,ELSE) o TESTS THE VALUE OF AN EXPRESSION WITH EACH

ALTERNATIVEo USES A CONSTRUCT TO MATCH A PATTERN WITH A

LIST OF ALTERNATIVESo PATTERN CAN USE A NUMBER, STRING WITH

LOGICAL OR “|” OR ASTERISK OR A RANGE, e.g., y|Y) or *) or 1) or a) or [A-Z]) or [A-Za-z]) or *[0-9]*)

o EACH ALTERNATIVE ASSOCIATED WITH SPECIFIC ACTION

o EXPRESSION CAN BE A VARIABLE ENTERED BY USERo EACH PATTERN LINE MUST END WITH ;; o EACH case SEQUENCE MUST END WITH easc

SCRIPTING INTERNALS: CASE CONDITIONAL

11/19/2009 rwj


• GENERIC FORMAT

case expression inpattern1) commands1 ;;

pattern2) commands2 ;;

pattern3) commands3 ;;. . . patternn) commandsn ;;

esac



• EXAMPLE:# Use of a case statement to offer a 5 item menuecho “ Menu\n1. List of files \n2. Processes of user\n3. Today’s date4. Users of system\n5. Quit to Unix\nEnter your option #: \c”

read choicecase “$choice” in

1) ls -l;;2) ps -f;;3) date;;4) who ;;5) exit ;;*) echo “Invalid option” # ;; not needed for last option

esac



• LETS A SET OF INSTRUCTIONS BE REPEATED WHILE A CONDITION EXISTSo do AND done DELIMIT THE LOOP BODYo SOURCE VALUES FOR list IN for LOOP IS YOUR

CHOICE – FILENAME, VARIABLE

SCRIPTING INTERNALS: FOR/WHILE/UNTIL LOOPS

while condition is true do

commands done

for variable in list do

commands done

for var in $PATH $HOME


• EXAMPLE: CREATE A BACKUP COPY OF EACH FILE NAMED IN A LIST

• LIST CAN USE WILD-CARD, E.G., CHAPT2*


$ for f1 in chapt20 chap21 chap22 ; do> cp $f1 ${f1}.bak> Echo $f1 copied to $f1.bak> done

NOTE: WHITE SPACE SEPARATES MEMBERS OF LIST, HOWEVER WHITE SPACES IN QUOTES ARE TREATED AS ONE WORD IN THE LIST , E.G., Q4 Q5 Q6 “Q7 87”


• while / do LOOP – TO WAIT A WHILE, AND THEN EXECUTE THE COMMAND AGAIN, OR EXECUTE A COMMAND INDEFINITELY OR USE TO EXECUTE A FINITE NUMBER OF TIMES.

• EXAMPLE: RUN A COMMAND 5 TIMES

• DECREMENT OR INCREMENT THE VALUE OF VARIABLE “X” EACH ITERATION OF THE LOOP$ x=5$ while [ $x –gt 0 ] ; do> ps –e ; sleep 3> x=èxpr $x - 1`> done



• expr :: 4 BASIC ARITHMETIC OPERATIONS ON NUMBERS • ADD, SUBTRACT, MULTIPLY, DIVIDE• ESCAPE MULTIPLY SIGN \*$ x=3; y=5$ expr 3 + 5 # simple sum using numbers$ expr $x - $y # simple difference using variables$ expr $x \* $y # escape the astrisk$ expr $y / $x # decimal truncated$ z=èxpr $x \* $y`; echo $z # create new variable

ARITHMETIC OPTIONS: COMPUTATION WITH expr


• expr :: TO VALIDATE LENGTH OF OR EXTRACT STRINGS • USES 2 EXPRESSIONS SEPARATED BY A

COLON• DETERMINE LENGTH OF STRING:

$ expr “robert_kahn” : ‘.*’ # white space around :

ARITHMETIC OPTIONS: COMPUTATION WITH expr

• VALIDATE LENGTH OF STRING:if [ èxpr “$name” : ‘.*’` -gt 20 ]; then


• EXECUTES A GROUP OF STATEMENTS ENCLOSED WITHIN { }

• FUNCTION NAME IDENTIFIED WITH () AFTER THE STRING INDICATING A NULL ARGUMENT LIST

functionName() {statementsreturn value # value is a number

}

SHELL FUNCTIONS


DEBUGING SHELL SCRIPTS: SHELL FUNCTIONS

2. COMMAND LINE EXAMPLE:$ ll() {> ls –l $* | more> }

1. COMMAND LINE EXAMPLE WITH RETURN VALUE SUPPORTING POSITIONAL PARAMETERS:

$ anymore() {> echo “$1 ?(y/n) : \c” 1>&2 > read input> case “$input” in> y|Y) echo 1>&2; return 0 ;;> *) return 1 ;; > esac> }


DEBUGGING SHELL SCRIPTS: DEBUG FUNCTION

• MOST BASIC WAY IS TO USE COMMAND set set -o verboseset –o xtrace

verbose ECHOES EACH COMMAND BEFORE RUNNING THEM TO stderr

xtrace ECHOES EACH COMMAND AFTER COMMAND-LINE PROCESSING, AFTER PARAMETER AND COMMAND SUBSTITUTION, AND THE OTHER SUBSEQUENT STEPS.

STARTS EACH LINE IT PRINTS WITH + WHICH IS CUSTOMIZABLE THROUGH THE BUILT-IN SHELL VARIABLE PS4. SO YOU CAN SET PS4 TO "xtrace-> "


DEBUGGING SHELL SCRIPTS: DEBUG FUNCTION

• OTHER WAYS:– USE PS4='$0 line $LINENO: ‘ TO DISPLAY THE FILE

NAME AND LINE NUMBER– USE PS4= “xtrace-> ” TO CHANGE THE INDICATOR– IF CODE DEBUGGING CALLS OTHER FUNCTIONS DEFINED

ELSEWHERE, USE THE SAME WAY WITH AN OPTION TO THE TYPESET COMMAND.

TO TRACE THE NAMED FUNCTION (fnName) WHENEVER IT RUNS, ENTER THE COMMAND IN THE SHELL THAT CALLS IT

typeset -ft fnName, # f = fn, t = trace


SHELL PROGRAM DESIGN TECHNIQUES:BASICS OF SCRIPT WRITING

• WRITING ANY SCRIPT INVOLVES THESE STEPS: • RUN THE UNIX COMMAND INTERACTIVELY AT A SHELL

PROMPT.• CREATE THE SHELL SCRIPT CONTAINING UNIX

COMMAND AND SHELL CONSTRUCTS.• MAKE THE SHELL SCRIPT EXECUTABLE.• TEST THE SCRIPT.• LAUNCH THE SCRIPT.

1. INTERACTIVELY2. ONCE, AT A FUTURE DATE AND TIME3. REPEATEDLY ON A FIXED SCHEDULE

• EMPLOY A CONVENTION FOR NAMING & STORING SCRIPTS



• SCRIPT WRITING TIPS: • START SCRIPTS WITH A COMMENT LINE THAT EXPLAINS

THE SCRIPT’S PURPOSE.

• USE UPPERCASE WHEN DEFINING VARIABLES. USE UNDERSCORES ( _ ) TO SEPARATE WORDS.

• EXPORT ENVIRONMENT VARIABLES TO PROVIDE ANY SUB-PROCESSES WITH AUTOMATIC ACCESS TO THE VALUES.



• SCRIPT WRITING TIPS (CONT’D): • TO USE THE OUTPUT OF A UNIX COMMAND

ELSEWHERE IN SCRIPT, TYPE A $, ENCLOSE THE COMMAND WITHIN PARENTHESES (), AND STORE THE OUTPUT IN AN ENVIRONMENT VARIABLE, E.G., VAR1=$(command1|command2)

• TO USE A VALUE OF AN ENVIRONMENT VARIABLE, PUT A $ IN FRONT OF THE VARIABLE NAME AND TO AVOID AMBIGUITIES, ENCLOSE THE VARIABLE NAME INSIDE CURLY BRACES {}

• WHEN RUNNING A SCRIPT FROM THE CURRENT DIRECTORY, PRECEDE A SCRIPT NAME WITH DOT-SLASH (./) TO INSTRUCT THE SHELL TO LOOK IN THE CURRENT DIRECTORY



• SCRIPT WRITING TIPS (CONT’D): • REDIRECT stderr, EITHER TO THE SAME DESTINATION

AS stdout OR TO A UNIQUE FILE

• REDIRECT stdout ( >) TO A FILE, OR APPEND stdout ( >> ) TO A FILE

• USE THE FOR-LOOP OR WHILE LOOP OR CASE LOOP TO PROCESS A LIST OF THINGS

Documents

Unix Comp-145