1 Syntax of Control Characters - ^A ^B ^C etc. Index

The syntax ^C stands for the single ASCII character CONTROL-C often written as CTRL-C or perhaps [CTRL-C]. To generate this character from your keyboard, hold down the CTRL key and simultaneously push the letter C key (upper or lower case; doesn’t matter). This syntax and method applies to all the control characters, e.g. ^A, ^B, ^C, ^D, etc.

2 What is a shell for? Index

To find and run programs.
(“Programs” are also called commands or utilities.) A shell is itself a program that finds and runs other programs.

Shells also do programming kinds of things, but that programming is usually to aid in the finding and running of programs, not to do any kind of substantial mathematical or business calculations. (Shells do not do mathematics very well.)

Part of running a program involves supplying command line arguments to that program; the shell helps with that, too.

Command names typed into shells almost always resolve to be the names of executable files stored in system directories. (Some command names are not files; they are built-in to the shell, such as cd.)

For example, the shell may resolve the command name ls to run the executable file /bin/ls, passing it any arguments you type on the command line. You can control where the shell looks for command executables by setting the $PATH variable.

3 What is a “Bourne” shell? What is a “C” shell? Index

The shells sh, ksh, zsh, and bash (the “Bourne” shells) all have a common ancestry. They are all derived from the original shell “sh” written in the 1970’s by Stephen Bourne. The programming features of these shells (if statements, for loops, etc.) all look and work the same way. This is the best shell to study.

The shells csh and tcsh (the “C” shells) are similar, having a history dating back to Bill Joy at Berkeley in the 1980’s. Their syntax for programming is not the same as the Bourne shells. We do not cover the C shell syntax in this course; these shells are notoriously buggy.

C Shell Bugs: Google for:   c shell bugs

My list of C Shell Bugs: Google for:   c shell bugs idallen

4 How does the shell help find and run commands? Index

• Shells look for command name executable files in various places, using a list of directories stored in the $PATH environment variable.

• Shells provide ways of editing the command line you type, so you can change words, insert text, etc., using fast editor commands instead of the slower arrow and backspace keys (which may not work on all systems).

• Shells provide ways of completing command and file names, to save typing. (The shell always spells names correctly when it completes them!)

• Shells provide a “history” mechanism to recall and edit the last commands you enter, to save retyping them. You can save your command history and have a written record of what you did yesterday.

• Shells provide aliases and variables to save typing the same things (commands or pathnames) over and over. You can create your own customized command names, e.g. a custom version of ls that always shows hidden files.

• Shells provide wildcards (GLOB patterns) to generate lists of pathnames as arguments for commands. Instead of having to select names one-by-one, shell GLOB patterns can match thousands of pathnames.

5 Using a Shell inside a Terminal Index

Shells run inside “terminals”, usually software terminal windows on modern GUI systems. These terminals recognize some useful command sequences that aid in typing commands. Below are some common command sequences:

   CTRL-C - *interrupt* a running foreground program
   CTRL-D - send *End-of-File* (EOF) from your keyboard (end input)
   CTRL-Z - temporarily *suspend* a process; restart by typing "fg"
   CTRL-U - erase input characters back to the start of the prompt
   CTRL-W - erase just the last word you typed (repeat for next word)

The above commands are properties of the terminal, so they work for any program that reads your keyboard, not just shells. You can change any of the above mappings using the stty command.

Note that suspending a text editor (such as vim) is a very dangerous thing to do, since having multiple editors all editing the same file can cause data loss if you write out an old version of a file on top of a newer one. Be very careful about suspending processes. Suspending is not the same as killing or terminating!

6 Basic Command Line Syntax Index

Most Unix commands need both a VERB (what to do - the command name) and an OBJECT (what to do it on - a command argument):

   $ cat /etc/passwd               (command argument is a file name)
   $ mail idallen@idallen.ca       (command argument is an email address)
   $ kill 1234                     (command argument is a process number)

The following incorrect attempts at Unix commands are wrong:

   $ /etc/passwd         (missing VERB; what are you trying to DO?)
   $ cat                 (missing OBJECT; catenate WHAT file?)

Remember to tell Unix both what you want to do and to what object you wish to do it:

   $ cat /etc/passwd
   $ less /etc/passwd
   $ wc /etc/passwd
   $ sort /etc/passwd

7 Most (but not all) commands take what as arguments? Index

Most - but not all - Unix commands take pathnames as arguments. Much of what people do on their computers is manipulate files and directories. This is why shells have GLOB pattern matching characters.

“Pathnames” are names that might be file names or directory names. (Unix also has names that are neither files nor directories, e.g. the /dev/null pathname is a “character special” device.)

The shell has GLOB (wildcard) features to make matching pathnames easier. e.g. try: $ echo /bin/*

8 Getting Out of Programs - exit, quit, etc. Index

Different Unix programs have different ways of ending or exiting from them. If you’re stuck at a prompt and can’t get out, try various things such as these:

h or help or ?

q or Q or quit
:q!  (used in VI to exit without saving)
x or exit
^D   (CTRL-D)
^C   (CTRL-C)
logout
bye
ESC  (the ESC key)
.    (a period)
^\   (CTRL-backslash)

One of the above usually works. Sometimes you can use ^Z (CTRL-Z) to “stop” the process temporarily, and then type “kill %%” to terminate it. (Remember to terminate it, or it will sit there waiting forever. A process stopped with ^Z still has all its files open.)

9 Interrupting Processes and signalling End-of-File - ^C and ^D Index

The terminal emulator treats the characters ^C and ^D specially.

$ sort >out
enter some lines of text and then
interrupt the program
and you will get an empty file
^C
$ cat out
$ 

$ sort >out
enter some lines of text and then
use an EOF to signal end of file
and sort will sort your data and finish
^D
$ cat out
and sort will sort your data and finish
enter some lines of text and then
use an EOF to signal end of file
$

10 Nested Shells inside Shells Index

Your default login shell on Linux is the Bourne-Again shell (bash). You can call up other shells by name if they are installed: sh, ksh, bash, csh, tcsh, etc. Not all shells may be installed on your system.

You can call up a shell inside a shell (a “nested” shell) by typing its name at the shell prompt (e.g. bash). The new copy of the shell will take over reading your keyboard until you exit from it again and the previous shell returns to read your keyboard.

To exit from a shell type: exit

When you exit from the first shell in a terminal, either the terminal window closes (if using a terminal window), or, if you are logged in directly to a Unix/Linux console, you log out from Unix.

Another way to exit a shell is to type your EOF character. (Your EOF character is usualy CONTROL-D.) Some shells can be told to ignore EOF.

Remember: all Unix programs (should) have manual pages!

$ man sh
$ man ksh
$ man bash
$ man csh
$ man tcsh

Each new shell is another Unix process. To get a list of your current processes in the current terminal, use: ps

11 Shell interactive pathname completion Index

If you type part of a pathname on a comand line and then push the TAB key (once or twice), many shells will attempt to complete the pathname for you. If the pathname cannot be completed unambiguously, the shell will show you a list of possible completions:

   bash$ echo /etc/pas<TAB>
   passwd      passwd-     passwd.OLD  

If you type part of a command name and push TAB, the shell will list all the possible commands in your PATH that start with those letters:

   bash$ mkd<TAB>
   mkdep      mkdict     mkdir      mkdirhier  mkdosfs    

Use the shell to do your typing for you - learn how to use the TAB key! (The shell always spells your pathnames correctly!)

12 Shell “history” of previous commands Index

Most shells keep a record (“history”) of the commands you type. The history is often saved in a file when the shell exits, and is restored when you next log in. You can see the history list using the built-in “history” command.

Many shells allow you to use the UP-ARROW and DOWN-ARROW keys to move up and down in the command history. (Some shells use other key sequences, such as ^P and ^N.) Move up to the command you want to re-execute, modify it as needed, then use [Enter] to execute it.

Some shells let you select items from the history list by number (e.g. “!123”). See History in your shell’s man page.

Each shell has its own separate command history. Starting a new shell will start an independent history any may not pick up the history of another shell unless that other shell saved it and your new shell loads it.

13 Shell command line alias trouble Index

Watch out for “helpful” system administrators that define aliases for your shells when you log in. (This is true on most versions of Unix/Linux.) The aliases may mislead you about how Unix commands actually work.

For example, the rm command does not prompt you for confirmation when removing a file. On some systems, when you log in, rm has been made to be an alias for rm -i, which does prompt. If you become accustomed to the behaviour of the alias, you will be in serious trouble when you move to a system that does not define the alias.

To avoid pre-defined aliases, sometimes you can start up a fresh copy of the shell that has no aliases defined:

   $ alias
   [...many aliases may print here...]

   $ bash
   bash$ alias
   [...no more aliases here...]

The other thing you can do is execute unalias -a to remove all your aliases for the current shell. You can put this into your shell start-up file (e.g. .bashrc) to do it every time you start a new shell.

To define your own aliases, look up “aliases” in a Unix/Linux text index, e.g.:

   $ alias dir='ls -lF'
   $ alias cd..='cd ..'
   $ alias mali=mail

Aliases defined in the current shell are not saved when the shell exits. You must put your own alias definitions in a shell start-up file to have them restored between sessions (e.g. put them into your .bashrc file).

Each shell has its own separate aliases. Starting a new shell does not get the aliases defined in other shells.