CSH COMMAND LANGUAGE

Filename Matching

The shell provides wildcards for matching filenames. They are typically used to match pass groups of files to a command.

An asterisk matches zero or more characters of a filename, and a question mark matches any single character. [However, neither the asterisk nor the question mark will match a leading dot in a filename and nor will they match a slash character.]

Examples:

Suppose that the current directory contains these files:

.foo, bar, aaa.c, bbb.c, aaa.o, v1-xxx.c, v1-xxx.txt

`*.c`	matches `aaa.c bbb.c v1-xxx.c`
`v1-*.c`	matches `v1-xxx.c`
`v?-xxx.c`	matches `v1-xxx.c`
`*`	matches all the files but `.foo`
`.`	matches all the files but `.foo` & `bar`
`*.?`	matches `aaa.c bbb.c aaa.o v1-xxx.c`

Curly braces may be used to enclose alternative groups of characters when forming a filename. For example, aaa.{c,o} matches both the filenames aaa.c and aaa.o.
Multi-level patterns are OK. For example, */*.c matches all .c files located in a subdirectory. But the pattern extends down only one level. To go down one or two levels, you would have to type
```
		*/*.c */*/*.c 
```
There is no shell notation to match filenames in subdirectories at arbitrary depths. (The find command provides this capability.)
If the filename pattern fails to match anything, the shell prints the terse message No match.

[This gives rise to a Unix joke ... type the following at a command prompt:
```
 hey Unix, got a light? 
```
]

Job Control

You can easily execute two commands simultaneously if you type the two commands in two different windows. If you are connected to the system by a slow link (e.g. a telephone line), you may not have multiple windows available. Here is how you can set several programs running simultaneously using a single window.
Any job (a program) can be in one either of the two states Running and Stopped .

There can be several running jobs. The shell designates one of these as the foreground job; all the others are considered to be background jobs. (Note: if you have two windows open, you have two shells running, and you can have a foreground job for each window.)

There can be several stopped jobs too.
A job can be started in the background by suffixing the command with the ampersand character. For example:
```
		make >& make.messages & 
```
When you type a command like that, you receive a prompt for a new command almost immediately. The shell has created the background job, and then comes back to accept the next command. The interactive dialogue looks something like this:
```
		% make >& make.messages &
		[1] Running
		make >& make.messages
		% 
```
The number 1 in square brackets is a job number. You can use this number in later commands.

If you start a second command in the background before the first one has finished, the dialogue might look like this:
```
		% grep '#include' *.c > inclist &
		[2] Running
		grep '#include' *.c > inclist
		%
	
```
A foreground job can be stopped by typing ^Z (control-Z). For example, the dialogue might go like this:
```
		% cc -c giganticFile.c
		^Z
		[1] Stopped
		cc -c giganticFile.c
		%
	
```
A background job can also change to the Stopped state if it requests input from the keyboard or attempts output to the screen. If it happens, you are likely to see a message like this:
```
		[2] Stopped (tty output)
		grep '#include' *.c > inclist
	
```
A stopped job can be restarted in the foreground by using the fg command. (This is what you must do if the job is stopped waiting to perform keyboard input or screen output.) If there is only one stopped or background job, you can type:
```
		fg 
```
However, if there are two or more stopped or background jobs, you should specify which job you want to bring into the foreground. There are two notations. One uses the job number. E.g.
```
		fg %2 
```
brings job number 2 into the foreground as it executes. The second notation uses the command name. E.g.
```
		fg %make 
```
brings the make command into the forgraound.
A stopped job can also be restarted as a background job. E.g.
```
		% bg %1
		[1] Running
		make >& make.messages
		%
	
```
Putting these together, if you wish to convert a foreground job into a background job, first halt it with ^Z and then use the bg command.
You can see the list of all jobs known to your shell by typing the command:
```
		jobs 
```
The output shows the job number, the status of the job, and the command that created the job.

Aliases

The csh shell allows you to define aliases for commands. These aliases may be used to provide different names for commands and/ or to supply command line arguments.
Examples:
```
	    alias copy cp
	    alias quit exit

	    alias rm rm -i 
```
Subsequently, you may use the name copy as a synonym for cp.

[Note that the rm example does not cause the shell to go into an infinite loop. And if you try:
```
	    alias foo bar
	    alias bar foo 
```
you will get a polite error message when you type foo or bar as a command.]
Alias definitions should be placed in your .cshrc file.
A list of all your current alias definitions may be obtained by typing the command alias.
If you wish to deactivate an alias, the unalias command may be used. E.g.
```
		unalias rm 
```
would remove our alias for rm, above.

Shell Script Basics

Any sequence of shell commands can be saved into a file. Such a file is called a shell script file. There are Bourne shell scripts, csh shell scripts, and so on. We are covering only csh script files here.
As an example, suppose that file "fpr" contains exactly these two lines:
```
		# My fpr program
		fmt myfile | lpr -Paixlw
	
```
We can run the commands in this file by either of these two approaches:
1. type the command
```
		csh fpr
		
```
2. make fpr into an executable file and then use the filename as though it were a command:
```
		chmod +x fpr	## this need be done once only
		fpr
		
```
For approach #2 to work, the script file fpr must be located in a directory in your shell's ``search path''. Recall that you can see your current search path by executing:
```
		echo $path 
```
and that you can add an additional directory to your directory by executing a command like:
```
		set path = (~/bin $path) 
```
where ~/bin is the new directory. [It is conventional to have a directory named bin in your home directory to hold any new commands that you want to create.]
The set path = ... command should be placed in your .login file and/or your .cshrc file. (These files are located in your home directory.) The commands in the .login file are executed whenever you log into the system; the commands in your `.cshrc' file are executed whenever you start up a new command shell. If you plan on using X-Windows, put the command in your .cshrc file.
A csh shell script must have a `#' character as the first character of the first line. (Without this, the Unix system will assume that the file contains commands for the Bourne shell, sh.)
The `#' character starts a comment which continues up to the end of the line.

Parameterizing csh Shell Scripts

Our fpr script, above, would be more useful if the name of the file to be printed were not hard-coded into the script.
We would like to use the command in this manner:
```
		fpr myfile1 
```
to format and print the contents of myfile1.
Simple parameterization can be achieved by changing our fpr file to hold these two lines:
```
		#
		fmt $argv[1] | lpr -Paixlw
	
```
The object argv is an array whose elements contain arguments provided on the command line. The notation $argv[k] gives you the value of the k-th argument.

Final Notes

The csh syntax is a complete programming language which supports variables, arrays, assignment statements, if statements, loops, goto statements, and more.
The language differs from a conventional programming language only in that the values which are manipulated tend to be names of files. Such a language is often called a scripting language.
As an example:
```
		set F = aaa.c 
```
assigns the the string of characters aaa.c to variable F, and subsequently we can access the string stored in F by writing $F. E.g.
```
		cc -c $F 
```
would issue the command to compile file aaa.c.
We are not covering csh much as a scripting language because perl seems to be a better scripting language and which is available most operating systems.
Here is one useful example of a csh control structure. Suppose that we wish to rename all files in the current directory by prefixing them with the characters `old-'. E.g., file aaa.c would be renamed to s old-aaa.c, and similarly for all other files. The csh command to achieve this effect is:
```
		foreach F (*)
		mv $F old-$F
		end 
```
You may type this command interactively. (When the csh shell sees the foreach command, it keeps reading input until the matching end command is typed; then it sets variable F to each filename in the current directory in turn, executing the loop body for each such value.)
More detailed information about csh commands can be found by typing
```
		man csh 
```
or from books. As noted above, though, much of the usefulness of csh has been superceded by perl.