The Shell

The UNIX and Linux command interpreter or shell is the program users interact with in a terminal emulation window. The terminal emulation window can be one in the workstation's Graphical User Interface - gnome-terminal on Linux or dtterm on Solaris. Alternatively, it can be an application such as telnet, secure shell client or PuTty on a Windows PC that's logged into Linux or UNIX over the network.

The shell used in the School of Computer Science & Informatics is bash - Bourne Again Shell. There are other shells available such as the Bourne Shell, the C-Shell and the TC-Shell, and you can choose to use a different shell if you prefer. They all have similar characteristics but each has its own particular features. This Note assumes you are using bash.

Bash has the following features:

• a command prompt which may be configured by the user. The default prompt is

  bash-2.05$

  - a dollar symbol preceded by ``bash'' and the bash program's version number.
• the shell, like other programs on UNIX and Linux has an associated current directory. Programs running on UNIX and Linux use the current directory as the starting point when locating files. The shell command

  bash-2.05$ cd

  is used to change the current directory to a different location in the UNIX or Linux file system.
• commands are invoked by naming them. Most UNIX and Linux commands are simply programs which are executed by the shell. For example,

  bash-2.05$ ls

  runs the program ls which reads the current directory and lists the names of its files.
• When you type a command name, the shell will check to see if the command is built-in and will otherwise search a set of directories until it finds the program. This set is known as the search path.

  The search path includes the current directory, your home directory and its subdirectory ``linuxbin'' or ``solarisbin'' (depending on whether you are logged in to Linux or Solaris). You can write your own programs and invoke them simply by typing their names. If you store such a program in the directory ``linuxbin'' or ``solarisbin'' as appropriate, it will be found and run no matter what your current directory is.

• commands often have argument strings which may, for instance, represent filenames. E.g.

  bash-2.05b$ cd ~/linuxbin

  change the current directory to ``linuxbin'' in your home directory. (The tilde character ~ means your home directory to the shell.

  Some commands need more than one argument. E.g.

  bash-2.05b$ cp fileA fileB

  is the copy command cp with two filename arguments; ``fileA'' is copied to a new file, ``fileB''.

  Some commands have flag or option argument strings usually beginning with ``-'' or ``-''. The flags modify the behaviour of the program being invoked:

  bash-2.05b$ ls -lt

  makes ls give a long listing of the files sorted by time of creation.
• the shell will expand wildcards to match filenames in the current directory. For example,

  bash-2.05b$ ls -l *.c

  will give a directory listing of the files with names ``anything.c'' (conventionally C program source files).
• most UNIX and Linux commands and programs adhere to a concept of standard input and standard output. The standard input is a stream of data which the program reads and the standard output is a stream of output written by the program. Often these are both attached to the terminal so that input comes from your keyboard and output goes to your screen. The shell lets you redirect the standard input and output.

  The symbol ``$<$'' is used to redirect standard input from a file and the symbol ``$>$'' is used to redirect standard output to a file. For example:

  bash-2.05b$ cat $<$ fileA

  makes cat reads from file ``fileA''. It outputs the file's contents to the terminal or screen.

  bash-2.05b$ cat $<$ fileA $>$ fileB

  reads from ``fileA'' and writes to ``fileB''.
• the Shell has the facility to pipe the output of one program to the input of another. The pipe symbol is ``$\vert$''. For example:

  bash-2.05b$ ls $\vert$ wc -w

  pipes the output of ls (viz., your filenames) into the word count program wc. The ``-w'' flag tells wc to count the number of words in its input. So the above command counts the number of files in your directory.
• You may assign aliases for commands or groups of commands:

  bash-2.05b$ alias xx=exit

  sets up an alias ``xx'' to stand for the command exit.
• the shell has string and numeric valued variables.

  bash-2.05b$ x="hello world"
  bash-2.05b$ echo $x

  prints ``hello world'' on the screen. Some variables are pre-set, e.g. $HOME is your home directory. Type set to see a list of assigned variables.
• Bash is an interpretive programming language with while loops, for loops, if-then-else statements, etc. See the UNIX or Linux on-line documentation for more details. Type

  bash-2.05b$ man bash
  

  to view its manual page.
• scripts of shell commands can be written. These can be invoked in the same way as compiled programs (i.e. just by naming them). For example:

  bash-2.05b$ cat $>$ ~/linuxbin/countfiles
  #!/bin/bash
  ls $\vert$ wc -w
  ^D
  bash-2.05b$ chmod +x ~/linuxbin/countfiles

  creates a bash script file in your ``linuxbin'' directory. The chmod command changes its protection mode to make it executable.

  The first line of the script tells Linux that the script is written in the Bourne again Shell language (UNIX and Linux scripts can be written in any application language), while the second line tells the Shell to run the directory listing command, ls, and pipe its output to the word count program, wc. Now

  bash-2.05b$ countfiles

  will execute the script and count and output the number of files in your directory,
• the shell has ``job control''. Programs which don't require any terminal interaction can be run in the background.

  bash-2.05b$ sort bigfile $>$ sortedfile &
  $[$1$]$ 3470
  bash-2.05b$

  The "&" puts the sort program into the background and the shell is available immediately for other commands. The shell prints the job control number (``1'' in this case) and the process identity number (``3470'').

  The special character ``^Z'' (Control-Z) can be used to suspend a program which is running in the foreground:

  bash-2.05b$ sort bigfile $>$ sortedfile
  ^Z
  $[$1$]$+ Stopped sort bigfile >sortedfile
  bash-2.05b$

  You may now use command bg to put the program into the background or fg to continue it in the foreground. If you have more than one job running in the background or suspended, you can refer to them by their job number. So

  fg %2
  

  bring job number 2 into the foreground while

  kill %1
  

  terminates job number 1.

  The command

  bash-2.05b$ jobs

  lists the status of all stopped or background jobs along with the job number (1,2,3...).

  If a backgound job needs terminal input, it will stop until you bring it into the foreground.

• the shell has a history mechanism - it remembers the last few commands.

  bash-2.05b$ history

  lists the remembered commands along with a reference number, e.g:

  515 cd .Intro
  516 ls -ltd 302*
  517 latex 302
  518 latex 302
  519 dvips -Ppdf -G0 -ta4 302
  520 ps2pdf 302.ps
  521 acoread 302.pdf

  In a workstation's terminal emulation windows, you can cut and paste from the history to rerun a command. You can also use the symbol ``!'' to rerun any command from the history:

  bash-2.05b$ !518

  reruns command number ``518'' from the history.

  bash-2.05b$ !ps

  reruns the last command starting ``ps...''.

  bash-2.05b$ !!

  reruns the last command.

See the manual page on bash for more details (type man bash).

Bash has an additional mechanism which allows you to recall and edit previous commands using the keyboard up-arrow key . If you press up-arrow, the last command re-appears on the terminal. Press up-arrow again to get earlier commands. To rerun the command, press . To amend the command before rerunning it, use the delete key to remove characters from the end or use the back-arrow to reposition the cursor to delete or insert characters within the command.