LECTURE
FOR
M.SC. CS III SEMESTER
SHELL PROGRAMMING
BY: POONAM YADAV
ASSISTANT PROFESSOR, CS
SHRI SHANKARACHARYA MAHAVIDYALAYA, JUNWANI,BHILAI

THE SHELL
• THE SHELL IS A HIGH-LEVEL PROGRAMMING LANGUAGE, MEANING THAT YOU DO
NOT HAVE TO WORRY ABOUT COMPLEX TASKS SUCH AS MEMORY MANAGEMENT.
THIS MAKES IT EASIER TO LEARN THAN A SYSTEMS PROGRAMMING LANGUAGE SUCH
AS C OR C++.
• SHELL PROGRAMS ARE GENERALLY FASTER TO WRITE THAN CORRESPONDING C
PROGRAMS, AND THEY ARE OFTEN EASIER TO DEBUG. HOWEVER, C PROGRAMS
ALMOST ALWAYS RUN FASTER AND MORE EFFICIENTLY.
• THEREFORE, SHELL SCRIPTING AND C PROGRAMMING ARE USED FOR VERY
DIFFERENT TASKS.
• FOR QUICKLY WRITING RELATIVELY SHORT TOOLS, SHELL IS A MUCH BETTER
CHOICE, BUT FOR LARGE SYSTEMS PROGRAMMING PROJECTS, C IS CLEARLY
SUPERIOR.

• ONE IMPORTANT FEATURE OF SHELL SCRIPTS IS THAT THEY ARE INTERPRETED
RATHER THAN COMPILED.
• THIS MEANS THAT WHEN YOU RUN A SHELL SCRIPT, THE SHELL PROGRAM ITSELF IS
INVOKED TO RUN THE COMMANDS IN YOUR FILE.
• YOU CAN EASILY TEST SHELL SCRIPTS AS YOU WRITE THEM JUST BY RUNNING THEM
FROM THE COMMAND LINE.
• IN CONTRAST, COMPILED LANGUAGES SUCH AS C ARE WRITTEN IN SOURCE FILES,
WHICH MUST BE CONVERTED TO BINARY EXECUTABLES BEFORE THEY CAN BE RUN.
• YOU CANNOT CREATE BINARY EXECUTABLES FROM YOUR SHELL SCRIPTS.

• IN COMPARISON TO OTHER SCRIPTING LANGUAGES, SUCH AS PERL, PYTHON, OR
TCL, THE SHELL PROGRAMMING LANGUAGE IS TIGHTLY INTEGRATED INTO UNIX.
• IT IS DESIGNED TO ALLOW YOU TO CALL UNIX COMMANDS AND TOOLS FROM
WITHIN YOUR SCRIPTS.
• THIS MEANS THAT YOU ALREADY KNOW MANY OF THE COMMANDS FOR
WRITING SHELL SCRIPTS, SINCE THEY ARE THE UNIX COMMANDS YOU USE
FREQUENTLY

• ADVANTAGES OF SHELL SCRIPTS
• THE COMMAND AND SYNTAX ARE EXACTLY THE SAME AS THOSE DIRECTLY ENTERED IN COMMAND LINE, SO
PROGRAMMER DO NOT NEED TO SWITCH TO ENTIRELY DIFFERENT SYNTAX
• WRITING SHELL SCRIPTS ARE MUCH QUICKER
• QUICK START
• INTERACTIVE DEBUGGING ETC.
• DISADVANTAGES OF SHELL SCRIPTS
• PRONE TO COSTLY ERRORS, A SINGLE MISTAKE CAN CHANGE THE COMMAND WHICH MIGHT BE HARMFUL
• SLOW EXECUTION SPEED
• DESIGN FLAWS WITHIN THE LANGUAGE SYNTAX OR IMPLEMENTATION
• NOT WELL SUITED FOR LARGE AND COMPLEX TASK
• PROVIDE MINIMAL DATA STRUCTURE UNLIKE OTHER SCRIPTING LANGUAGES. ETC

A SAMPLE SHELL SCRIPT
• A COMMON USE OF SHELL PROGRAMS IS TO ASSEMBLE AN OFTEN-USED STRING
OF COMMANDS.
• FOR EXAMPLE, SUPPOSE YOU ARE WRITING A LONG ARTICLE THAT HAS BEEN
FORMATTED FOR USE WITH NROFF AND THE RELATED TOOLS TBL AND COL.
• WHEN YOU WANT TO PRINT A PROOF COPY OF YOUR ARTICLE, YOU HAVE TO
ENTER A COMMAND STRING LIKE THIS:
$ CAT ARTICLE | TBL |
> NROFF -CM -RA2
-RN2 -RE1 -RC3 -RL66 -RW67 -RO0 |
> COL | LP -DPR2

EXECUTING YOUR SCRIPT
• THE NEXT STEP AFTER CREATING THE FILE IS TO MAKE IT EXECUTABLE.
• THIS MEANS SETTING THE READ AND EXECUTE PERMISSIONS ON THE FILE SO THAT THE SHELL CAN RUN IT.
• IF YOU ATTEMPT TO RUN A SCRIPT THAT IS NOT EXECUTABLE,
• YOU WILL GET AN ERROR MESSAGE LIKE SH: PROOF: PERMISSION DENIED TO GIVE THE PROOF FILE READ AND EXECUTE PERMISSIONS FOR ALL USERS, USE THE
CHMOD COMMAND:
$ CHMOD +RX PROOF
• NOW YOU CAN EXECUTE THE COMMAND BY TYPING THE NAME OF THE EXECUTABLE FILE.
• FOR EXAMPLE,
$ ./PROOF
• IF THE SCRIPT IS IN YOUR CURRENT DIRECTORY,
• OR
$ PROOF
• IF IT IS IN A DIRECTORY IN YOUR PATH. AT THIS POINT, ALL OF THE COMMANDS IN THE FILE WILL BE READ BY THE SHELL AND EXECUTED JUST AS IF YOU HAD
TYPED THEM.

WORKING WITH VARIABLES
• YOU CAN CREATE VARIABLES IN YOUR SCRIPTS TO SAVE INFORMATION. THESE WORK JUST LIKE THE SHELL
VARIABLES. YOU CAN SET OR ACCESS A VARIABLE LIKE THIS:
• MESSAGE="HELLO, WORLD"
• ECHO $MESSAGE.
• $ CAT DEV-CONFIG DEVPATH=/USR/PROJECT2.0/BIN:/USR/PROJECT2.0/TOOLS/BIN:$HOME/DEV/PROJECT2.0
EXPORT DEVPATH
• CD $HOME/DEV/PROJ ECT2.0
• THIS SCRIPT USES THE VALUE OF THE SHELL ENVIRONMENT VARIABLE $HOME. IT ALSO SETS A NEW VARIABLE,
CALLED DEVPATH. IF YOU WANT DEVPATH TO BECOME A NEW ENVIRONMENT VARIABLE, AND THE CD COMMAND
TO CHANGE YOUR CURRENT DIRECTORY, YOU WILL HAVE TO RUN THE SCRIPT IN THE CURRENT SHELL, LIKE THIS:
• $ . ./DEV-CONFIG

• YOU CAN USE ENVIRONMENT VARIABLES TO PASS INFORMATION TO YOUR SCRIPTS,
• AS IN THIS EXAMPLE, WHICH USES THE ENVIRONMENT VARIABLE ARTICLE TO PASS
INFORMATION TO THE PROOF SCRIPT WE SAW EARLIER:
$ CAT PROOF
CAT $ARTICLE | TBL | NROFF -CM -RA2
-RN2 -RE1 -RC3 -RL66 -RW67 -RO0 |
COL | LP -DPR2
$ EXPORT ARTICLE=ARTICLE2
$ ./PROOF

• THE KORN SHELL AND BASH ADD THE FOLLOWING USEFUL VARIABLES. THESE
ARE NOT STANDARD IN SH.
• PWD CONTAINS THE NAME OF THE CURRENT WORKING DIRECTORY.
• OLDPWD CONTAINS THE NAME OF THE PRECEDING WORKING DIRECTORY.
• LINENOIS THE CURRENT LINE NUMBER IN YOUR SCRIPT.
• RANDOM CONTAINS A RANDOM INTEGER, TAKEN FROM A UNIFORM
DISTRIBUTION OVER THE RANGE FROM 0 TO 32,767.
• THE VALUE OF RANDOM CHANGES EACH TIME IT IS ACCESSED.

ARRAYS AND LISTS
• THE KORN SHELL AND BASH ALLOW YOU TO DEFINE ARRAYS.
• AN ARRAY IS A LIST OF VALUES, IN WHICH EACH ELEMENT HAS A NUMBER, OR INDEX, ASSOCIATED WITH IT.
• THE FIRST ELEMENT IN AN ARRAY HAS INDEX 0.
• FOR EXAMPLE, THE FOLLOWING DEFINES AN ARRAY FILE CONSISTING OF THREE ITEMS:
FILE[0]=NEW
FILE[1]=TEMP
FILE[2] =$BACKUP T
• HE FIRST ELEMENT IN FILE IS THE STRING “NEW”. THE LAST ELEMENT IS THE VALUE $BACKUP. TO PRINT AN ELEMENT, YOU COULD ENTER
• ECHO ${FILE [2]}
• YOU CAN ALSO CREATE ARRAYS FROM A LIST OF VALUES.
• A LIST IS CONTAINED IN PARENTHESES, LIKE THIS:
• NUMBERS=(1 2 3 4 5) TO PRINT ALL THE VALUES IN AN ARRAY, USE * FOR THE INDEX:
• ECHO ${NUMBERS[*]}

WORKING WITH STRINGS
• KSH AND BASH INCLUDE SEVERAL OPERATORS FOR WORKING WITH STRINGS OF TEXT. TO FIND THE LENGTH OF A VARIABLE (THE NUMBER OF CHARACTERS IT CONTAINS), USE THE ${#VARIABLE}
CONSTRUCT.
• FOR EXAMPLE,
$ FILENAME="FIREFLY.SH"
$ ECHO ${#FILENAME} 10
• THE CONSTRUCT ${VARIABLE%WILDCARD} REMOVES ANYTHING MATCHING THE PATTERN WILDCARD FROM THE END (RIGHT SIDE) OF $VARIABLE.
• THE PATTERN CAN INCLUDE THE SHELL WILDCARDS INCLUDING * TO STAND FOR ANY STRING OF CHARACTERS.
• FOR EXAMPLE, $ ECHO ${FILENAME%.*} FIREFLY USES THE WILDCARD .* TO MATCH THE EXTENSION .SH, SO ECHO PRINTS THE FIRST PART OF THE FILENAME.
• THE VARIABLE FILENAME IS NOT MODIFIED. SIMILARLY, THE POUND SIGN CAN BE USED TO REMOVE AN INITIAL SUBSTRING.
• FOR EXAMPLE,
$ ECHO ${FILENAME#*.}
SH
• IN THIS CASE, THE WILDCARD *. MATCHES THE STRING “FIREFLY.”. ECHO PRINTS THE REMAINDER OF THE STRING, WHICH IS “SH”.

USING COMMAND-LINE ARGUMENTS
• YOU CAN PASS COMMAND-LINE ARGUMENTS TO YOUR SCRIPTS. WHEN YOU
EXECUTE A SCRIPT, SHELL VARIABLES ARE AUTOMATICALLY SET TO MATCH THE
ARGUMENTS. THESE VARIABLES ARE REFERRED TO AS POSITIONAL PARAMETERS.
THE PARAMETERS $1, $2, $3, $4 (UP TO $9) REFER TO THE FIRST, SECOND,
THIRD, FOURTH (AND SO ON) ARGUMENTS ON THE COMMAND LINE. THE
PARAMETER $0 IS THE NAME OF THE SHELL PROGRAM ITSELF.

• THE PARAMETER $# IS THE TOTAL NUMBER OF ARGUMENTS PASSED TO THE
SCRIPT. THE PARAMETER $* REFERS TO ALL OF THE COMMAND-LINE
ARGUMENTS (NOT INCLUDING THE NAME OF THE SCRIPT). THE PARAMETER $@
IS SOMETIMES USED IN PLACE OF $*; FOR THE MOST PART, THEY MEAN THE
SAME THING, ALTHOUGH THEY BEHAVE SLIGHTLY DIFFERENTLY WHEN QUOTED.

THE SET COMMAND
• THE SHELL COMMAND SET TAKES A STRING AND ASSIGNS EACH WORD TO ONE OF THE POSITIONAL PARAMETERS. (ANY COMMAND-LINE ARGUMENTS THAT ARE STORED IN THE POSITIONAL PARAMETERS
WILL BE LOST.)
• FOR EXAMPLE, YOU COULD ASSIGN ALL THE LIST OF FILES IN THE CURRENT DIRECTORY TO THE VARIABLES $1, $2, ETC., WITH
• SET * ECHO "THERE ARE $# FILES IN THE CURRENT DIRECTORY."
• BACKQUOTES CAN BE USED TO PERFORM COMMAND SUBSTITUTION.
• YOU CAN USE THIS TO SET THE POSITIONAL PARAMETERS TO THE OUTPUT OF A COMMAND.
• FOR EXAMPLE,
$ SET 'DATE'
$ ECHO $*
SUN DEC 30 12:55:14 PST 2006
$ ECHO "$1, THE ${3}TH OF $2"
SUN, THE 30TH OF DEC
$ ECHO $6 2006

ARITHMETIC OPERATIONS
• IF YOU HAVE USED OTHER PROGRAMMING LANGUAGES, YOU MAY EXPECT TO BE ABLE TO INCLUDE ARITHMETIC OPERATIONS DIRECTLY IN YOUR SHELL SCRIPTS.
• FOR EXAMPLE, YOU MIGHT TRY TO ENTER SOMETHING LIKE THE FOLLOWING:
$ X=2
$ X=$X+L
$ ECHO $X
2+1
• IN THIS EXAMPLE, YOU CAN SEE THAT THE SHELL CONCATENATED THE STRINGS “2” AND “+1” INSTEAD OF ADDING 1 TO THE VALUE OF X.
• TO PERFORM ARITHMETIC OPERATIONS IN YOUR SHELL SCRIPTS, YOU MUST USE THE COMMAND EXPR.
• THE EXPR COMMAND TAKES A LIST OF ARGUMENTS, EVALUATES THEM, AND PRINTS THE RESULT ON STANDARD OUTPUT. EACH TERM MUST BE SEPARATED BY
SPACES.
• FOR EXAMPLE,
• $ EXPR 1 + 2
• 3

LET COMMAND
• IN BASH AND KSH, THE LET COMMAND IS AN ALTERNATIVE TO EXPR THAT PROVIDES A SIMPLER AND MORE COMPLETE WAY TO DEAL WITH INTEGER ARITHMETIC.
• THE FOLLOWING EXAMPLE ILLUSTRATES A SIMPLE USE OF LET:
• $ X=100
• $ LET Y=2*(X+5)
• $ ECHO $Y
• 210
• NOTE THAT LET AUTOMATICALLY USES THE VALUE OF A VARIABLE LIKE X OR Y. YOU DO NOT NEED TO ADD A $ IN FRONT OF THE VARIABLE NAME. THE LET
COMMAND CAN BE USED FOR ALL OF THE BASIC ARITHMETIC OPERATIONS, INCLUDING ADDITION, SUBTRACTION, MULTIPLICATION, INTEGER DIVISION,
CALCULATING A REMAINDER, AND INEQUALITIES.
• IT ALSO PROVIDES MORE SPECIALIZED OPERATIONS, SUCH AS CONVERSION BETWEEN BASES AND BITWISE OPERATIONS. Y
• OU CAN ABBREVIATE LET STATEMENTS WITH DOUBLE PARENTHESES, (( )).
• FOR EXAMPLE, THIS IS THE SAME AS
• LET X=X+3
• (( X = X+3 ))
• CLEARLY, LET IS A SIGNIFICANT IMPROVEMENT OVER EXPR. IT STILL DOES NOT WORK WITH DECIMALS, HOWEVER, AND IT IS NOT SUPPORTED IN SH. THE
LIMITATIONS OF EXPR AND LET ARE A GOOD EXAMPLE OF WHY SHELL IS NOT THE BEST LANGUAGE FOR SOME TASKS.

CONDITIONAL EXECUTION
• AN IF STATEMENT TESTS WHETHER A GIVEN CONDITION IS TRUE.
• IF IT IS, THE BLOCK OF CODE WITHIN THE IF STATEMENT WILL BE EXECUTED.
• THIS IS THE GENERAL FORM OF AN IF STATEMENT:
IF TEST COMMAND
THEN
COMMAND(S)
FI

IF... ELIF… ELSE STATEMENTS
• THE IF ... ELIF ... ELSE OPERATION IS AN EXTENSION OF THE BASIC IF STATEMENTS JUST SHOWN.
• IT ALLOWS FOR MORE FLEXIBILITY IN CONTROLLING PROGRAM FLOW.
• THE GENERAL FORMAT LOOKS LIKE THIS:
• IF TEST COMMAND
• THEN
• COMMAND(S)
• ELIF TEST COMMAND
• THEN
• COMMAND(S)
• ELSE COMMAND(S)
• FI
• THE COMMAND FOLLOWING THE KEYWORD IF IS EVALUATED. IF IT RETURNS TRUE, THEN THE COMMANDS IN THE FIRST
BLOCK (BETWEEN THEN AND ELIF) ARE EXECUTED. IF IT RETURNS FALSE, HOWEVER, THEN THE COMMAND FOLLOWING
ELIF IS EVALUATED. IF THAT COMMAND RETURNS TRUE, THE NEXT BLOCK OF COMMANDS IS EXECUTED. OTHERWISE, IF
BOTH TEST COMMANDS WERE FALSE, THEN THE LAST BLOCK (FOLLOWING ELSE) IS EXECUTED. NOTE THAT, REGARDLESS
OF HOW THE TEST COMMANDS TURN OUT, EXACTLY ONE OF THE THREE BLOCKS OF CODE IS EXECUTED.

CASE STATEMENTS
• IF YOU NEED TO COMPARE A VARIABLE AGAINST A LONG SERIES OF POSSIBLE VALUES, YOU CAN USE A LONG CHAIN
OF IF ... ELIF ... ELSE STATEMENTS. HOWEVER, THE CASE COMMAND PROVIDES A CLEANER SYNTAX FOR A CHAIN OF
COMPARISONS. IT ALSO ALLOWS YOU TO COMPARE A VARIABLE TO A SHELL WILDCARD PATTERN, RATHER THAN
TO A SPECIFIC VALUE.
• THE SYNTAX FOR USING CASE IS SHOWN HERE:
CASE STRING IN
PATTERN) COMMAND(S) ;;
PATTERN) COMMAND(S) ;;
ESAC
• THE VALUE OF STRING IS COMPARED IN TURN AGAINST EACH OF THE PATTERNS. IF A MATCH IS FOUND, THE
COMMANDS FOLLOWING THE PATTERN ARE EXECUTED UP UNTIL THE DOUBLE SEMICOLON (;;), AT WHICH POINT
THE CASE STATEMENT TERMINATES. IF THE VALUE OF STRING DOES NOT MATCH ANY OF THE PATTERNS, THE
PROGRAM GOES THROUGH THE ENTIRE CASE STATEMENT

• CLEARLY, TYPING THIS ENTIRE COMMAND SEQUENCE, AND LOOKING UP THE OPTIONS EACH
TIME YOU WISH TO PROOF YOUR ARTICLE, IS TEDIOUS. YOU CAN AVOID THIS EFFORT BY
PUTTING THE LIST OF COMMANDS INTO A FILE AND RUNNING THAT FILE WHENEVER YOU WISH
TO PROOF THE ARTICLE. IN THIS EXAMPLE, THE FILE IS CALLED PROOF:
$ CAT PROOF CAT ARTICLE | TBL | NROFF -CM -RA2
-RN2 -RE1 -RC3 -RL66 -RW67 -RO0 | COL | LP -DPR2
THE BACKSLASH () AT THE END OF THE FIRST LINE OF OUTPUT INDICATES THAT
THE COMMAND CONTINUES OVER TO THE NEXT LINE. THE SHELL
AUTOMATICALLY CONTINUES AT THE END OF THE SECOND LINE, BECAUSE A PIPE
(|) CANNOT END A COMMAND.

THANKS !!!
REFERENCES
UNIX BY SUMITABHA DAS
UNIX COMPLETE REFERENCE