Working in the Shell Environment

Use the export command save the variable definition as and environmental variable and to pass the value of the assigned variable to future processes created by this shell. For example, if invoke a second Korn Shell, but have not exported a variable, the value of the variable will not be avaiable to applications run within this invocation of the shell. For example, consider the result of executing the following commands:

x='1+3'
echo  $x
ksh
echo  $x
exit
export x
ksh
echo  $x
ps
exit

Note: Be careful how many times you use the exit command as it may in logging off from the system. It is recommended that you use the ps command prior to issuing an exit command or pressing <Ctrl-D> so that you do not logout inadvertently.

Note: you can create an environmental variable as a single command: for example to create an environmental variable x having the value '1+3' as above, we could have entered:

export x='1+3'

C Shell

The "set" command is used to assign a text string to a C Shell variable.

• set t='today is '
• set d=`date`
• echo $t $d

Environmental Variables

Environmental (keyword) variables are used to define parameters used by the operating system and the system environmental variables are typically entered as all upper case names. Observe the results of entering each of the following commands:

echo  $HOME
echo  $TERM
env

The env ("printenv" command on some Unix systems) displays a list of the currently defined environmental variables.

Note: if the "env" command fails to display a list of the environmental variables, try using the command "printenv" instead.

Changing the System Prompt

If you are using the BASH, Bourne, or Korn Shell, you can change the displayed prompt by assigning a value to the PS1 environmental variable.

For example, in the Bourne Shell, to display your home directory followed by two greater than signs (>>) as the prompt, enter the following commands:

PS1='>> '
export $PS1

Note: To make these commands effective for future sessions, include them in the file ".profile" which is executed when you log into the system.

Note: The character used in the above example is an open single quote (', an apostrophe). If you do not pair quoting characters correctly, unexpected results may occur. If you observe only a single greater than sign when you attempt to assign '>> ' to the PS1 environmental variable, you have not paired your quote marks correctly. You can terminate entry of this command by pressing <Ctrl-C>.

In the Korn Shell, you can include the current command number and current directory as part of the displayed prompt by either entering the following pair of commands or by including them in the file ".profile" for use by future login sessions:

PS1='! $PWD>'
export $PS1

set prompt="$cwd"%
alias cd 'cd \!* ;set prompt="$cwd"%'

Modifying the PATH Variable

The PATH variable is used to store a list of directories which are searched when you issue a command. To display the current value of the PATH variable, simply enter:

echo  $PATH

To add an additional directory (e.g., my_new_directory) to the value of the PATH variable in the Bourne or Korn shells, use the following commands:

PATH=$PATH:my_new_directory
export PATH

Note: By default, the VT ARC systems do not include "." (the current directory) in the search path as doing so is considered a potential security risk!

Changing the PATH Variable When Using the C Shell

If you are using the C shell, use the following command to add a directory to the PATH variable:

set path=($path my_new_directory)

Note: The C shell uses both the "path" and "PATH" variables; the the value of the "PATH" variable is updated whenever the value of the "path" variable is changed. To assign a list of items to a variable when using the C Shell, enclose it in parentheses. The command "set" is used to assign a value to a C Shell variable in the local environment; "setenv" is used to assign a value to a C Shell variable in the global environment, i.e., the current environment and all future processes generated from this shell.

Evaluating Expressions and Assigning Numeric Values to Variables

The expr command can be used to evaluate numeric expressions. For example, consider the results of entering the following commands:

• counter=5
• expr $counter + 5
• x=`expr 5  +  9 `
• echo $x

Note: You must include spaces between each of the terms and operators when you use the expr command.

The "let" command can be used with the BASH or Korn Shell to evaluate expressions and assign the result to a variable. For example, using either of these shells, observe the results of entering the following commands:

• let counter=5
• let counter=2*$counter+5
• echo $counter

The "@" command can be used within the C shell to evaluate expressions and assign the result to a variable. If you are using the C Shell, observe the result of the following commands:

• @ counter = 5
• @ counter = 2 * $counter + 5
• echo $counter
• @ counter += 1
• echo $counter
• @ counter ++
• echo $counter
• set d=`date`
• echo $d
• echo $d[3]
• @ d[3] ++
• echo $d[3]

When "@" is used for expression evaluation with the C Shell, you must include a space before and after the equal sign as well as between each element which appears on the right side of the expression. In the last three examples, $d[3] corresponds to the 3rd element (day of the month) assigned to the variable "d" by the set command.

Command Alias Applications

The alias command is available in both the BASH, Korn, and C shells to provide substitution of a command or command string by an alternative name or abbreviation.

The alias commands illustrated in this section assume use of the Korn Shell. If you are using the C Shell, substitute a blank space for the equal sign in the example definitions. The alias command is not available in the Bourne shell.

The alias command is commonly used to:

• To minimize repetitive typing and thus reduce errors (i.e., create abbreviations):

  alias  h=history
  

• To create your own commands:

  alias listdir='find . -type d -print'
  

• To modify the action of an existing command:

  alias  ls='ls  -F'
  

• The -i option of the cp, mv, and rm command results in an interactive prompt being displayed prior to overwriting or removing each file which would be affected by the command. This option can be used to provide some protection from mistakes which would be caused by accidently overwriting or removing files. To obtain this protection, include the following alias definitions in .profile (Korn Shell) or .login (C Shell -- recall you should substitute a space for the equal sign in the alias examples).

  alias cp='cp -i'
  alias mv='mv -i'
  alias rm='rm -i'
  

  You will now be asked for confirmation prior to overwriting or removing an existing file. If you are using the C Shell and would like to prevent overwriting files by redirection, set the "noclobber" variable:

  set  noclobber

To display a listing of the currently defined aliases, simply enter the command:

alias

To remove an alias definition, use the unalias command. For example, to remove the alias of h for the history command, enter:

unalias  h

alias vi 'mesg n;/usr/ucb/vi \!*; mesg y'

Command History & Command Line Editing

The history command enables recall of previous commands for re-execution; it is not available for use with the Bourne shell.

BASH Shell History & Command Line Editing

To recall a prior command, simply press the up arrow key;  the down arrow key can be used to scroll back through the list of previously displayed commands.  To edit the current command line, simply use the right or left arrow keys to move to the appropriate position in the line.  You can insert new characters after the current cursor position by simply typing the text you wish to enter;  use the "Backspace" key to delete the character in front of the current cursor position.

The BASH Shell keeps a log of previously issued commands in the file ".bash_history". To review a list of previously entered comands, enter: history

You can also use the C Shell History commands described below.

Korn Shell History

The Korn Shell keeps a log of previously issued commands in the file ".sh_history". To recall a prior command, you must first specify which editor you would like to use with the command history. To use the vi editor, you must have first invoked the following command:

set  -o  vi

Now you can use vi commands to edit previous commands. First press <Esc> to enter vi command mode; a few of the most commonly used command line editing keys include:

k

recall the previous command. Pressing this key multiple times allows you to scroll back through previously issued commands.

l

(lower case L) allows you to move the cursor to the right one character at a time. Of course you can precede the "l" with a number to move the cursor the specified number of characters to the right.

h

allows you to move the cursor to the left one character at a time. Of course you can precede the "h" with a number to move the cursor the specified number of characters to the left.

A

enter insert mode at the end of the command.

a

enter insert mode after the current cursor position.

i

enter insert mode in front of the current cursor position.

I

(uppercase i) enter insert mode at the beginning of the line.

r

replace a single character

When you are finished editing a command, you can execute it by pressing the <Return> key.

C Shell history

If you are using the Korn Shell and would like to try using the C Shell interactive history features, enter the following command prior to issuing any to the other commands in this section (recall that you can return from the C Shell back to the Korn Shell by pressing <Ctrl-D> or entering the command exit):

csh

To use the C Shell history capabilities, you must first turn on the history command by assigning a number to the history variable. Include the following command in the file ".cshrc" to assign the value 23 to the history variable:

set  history=23

The following table illustrates how the C Shell history command can be used:

!!

re-execute the last command

!vi

re-execute the last command beginning with "vi"

!?fred?

re-execute the last command containing "fred"

!5

re-execute command number 5

!5:s/old_text/new_text

  re-execute command 5 and substitute "new_text" for "old_text"

old_text<caret>new_text

  re-execute the previous command and substitute "new_text" for "old_text". On most keyboards, the <caret>, also known as "hat" is obtained by pressing the shift key and then the number six key the "typewriter" section of the keyboard.

!-5

re-execute the fifth previous command

Execute the following commands and observe how the history capabilities enables recall of past commands and minimization of typing:

set  history=23
set  prompt='\!%'
mkdir xmp

ls -la
!!
ls -F
history
!-2
!cat

Unix Shell Scripts

Unix shell scripts provide a convenient mechanism for simplfing the execution of complex or repetitive command sequences.

Typically a "#" used within a shell script is used to indicate a comment; however, if "#" appears as the first character of the first line, its interpretation is different. You can begin a script with "#!/bin/sh" to indicate that the commands contained in the file are to be interpreted as a Bourne Shell script, #!/bin/csh for a C Shell script, or #!/bin/ksh for a Korn Shell script. If "#" appears as the first character of the first line and is not followed by "!", the results are system dependent, but may result in the commands within the file being interpreted in the language of the login shell.

Before a script can be executed, it must be given execute permission. Use the chmod command to make this file executable by user, group, and other:

   chmod   a+x   my_script

Applications

Shell scripts can include the following capabilities:

1. Evaluating Expressions
2. Processing Input Arguments
3. Conditional Processing
4. Looping

Shell scripts provide the following advantages over programming languages:

• Easy to write and maintain
• Don't need to compile and link
• Shells contain built in commands for fast execution

Passing Arguments

Numbers and text strings can be passed for use within a script on the command line following the name of the script when it is used. Each item passed to the script is known as an argument; blank space are used as the delimiter between arguements except any information which is enclosed within qoutes is considered as a single argument.

As an example, suppose we would like to create a shell which would add the values of two numbers entered on the command line and return the result. We could do so by creating a file called "add2" containing the following line:

echo "The sum of $1 and $2 is:   `expr $1 + $2`

A second example illustrating how arguments can be passed to a shell script is contained in the sample file "argtest". This shell first prints a list of all the arguments which were passed to it and then it prints a line for each argument it contains. This file also illustrates use of some of the flow control commands discussed in Flow Control. Observe the results of entering the following commands:

 ./argtest
 ./argtest one two three
 ./argtest a b c d e f g h i j k l m n o p q r s

The following arguments can be used within the Bourne, C, or Korn Shells:

$*

all arguments (alternatively you can also use $argv[*] or $argv in the C Shell).

$1...$9

arguments 1 to 9.

The following arguments can be used only for the Bourne and Korn Shells:

$#     number of arguments.

$?     error return code.

$a     all arguments on the command line individually quoted.

The following arguments can only be used with the C shell:

$0     name of the program.

$argv     number of arguments.

$argv[n]     argument n (n is between 1 and 9, $argv[0] is invalid).

$argv[1-n]     arguments 1 to n (9 is maximum value for n).

argv[$#argv]     the last argument.

Flow Control

The Shells contain the following types of control structures to provide conditional and loop processing:

• if (expression) command [C Shell]
• if-then structures
• if-then-else structures
• if-then-elseif-else structures
• switch and case structures
• for (loop) structures
• while structures
• until structures [Bourne, Korn, & BASH shells]
• goto statements [C Shell]
• continue statements
• on interrupt (onintr) statements [C Shell]

The example program "argtest" illustrates use of three of these structures. Since the first line of this shell begins with "#!/bin/sh", this shell will be executed using the Bourne Shell. Following the first line the script assigns initial values to the variables n and total. A blank line is then printed by the echo command.

The first control structure is an "if-then" which is used to print a message if no arguments were included when the command was entered. The "if-then" conditional begins with a test of the expression "$# -lt " and ends with the "fi" ("if" spelled backwards) statement. If the number of arguments is less than 1, the "then" statements are executed. In this example, a message is displayed indicating that there were no command line arguments, a blank line is printed, and the script is terminated by the "exit" statement.

When there are one or more arguments, the above "if" condition is not satisfied and the program continues by printing (echo) the list of arguments passed to the script. The "if" conditional statement is followed by a "while-do" structure (terminated by a "done" statement) which indicates that all of the statements are to be repeated so long as the current value of $n is less than or equal to the number of command line arguments. Note that the value of "$n" is incremented by 1 just before the "done" statement.

Following the "do" statement is a "case" control structure which ends with the statement "esac" ("case" spelled backwards). This "case" structure examines the value of "$n". If it is "1", control is forwarded to the statement beginning with "1)" and it prints a message that the value of the first argument is "$1". Similar statements are included for "$n" in the range 2 through 9. If "$n" is greater than 9, then control is passed to the statements following "*)". Here the shift command is issued and a message is printed indicating that the value of the nth argument is equal to "$9" (recall our prior discussion of the shift command and its effect upon the values associated with the shell variables $1 through $9). After all of the arguments have been processed, the script continues after the done statement by printing a blank line (echo) and then exits. This program was written to illustrate use of the "case" control structure as well as the "while-do" and "if-then" structures. If we had not been interested in illustrating this control structure, this script could have been simplified by substituting the following statements for all of the statements between and including the "case" and "esac" statements:

echo "Argument $n is:  $1"
shift
n=`expr $n + 1`