Csh

Table of Contents

• C shell problems
• Quoting long strings, $ and !
• The ad hoc parser
• Reading one line at a time
• File redirection
• Signals, Traps and child processes
• A time bomb
• Quoting C Shell Meta-Characters
• Using the backslash
• Strings in single quotation marks
• Strings in double quotation marks
• Solving special cases
• Passing variables inside a string
• C shell Globbing
• Globbing
• Match a single character
• Matching character sets
• Combining meta-characters
• In-line expansion
• Home directory expansion
• C Shell Variable Usage
• Passing arguments to a shell script
• Arguments generalized as array lists
• Clearing array lists
• Testing for variable existence
• The Shift command
• C Shell Flow Control
• Optional forms of the if command
• Problems with the if command
• The While command
• The Foreach command
• The Switch statement
• Complex Expressions
• Commands that use expressions
• Examples
• Tricky expressions to test
• Parenthesis in the C shell
• Break and continue
• Interactive Features of the C shell
• Bill Joy's Legacy
• C shell File Redirection
• The noclobber variable
• Safe Aliases
• C Shell Start-up Files
• The .cshrc file
• The .login file
• The .logout file
• What goes where?
• The tricky part about start-up files
• The C shell prompt variable
• The current terminal
• Local variables vs. Environment variables
• Other conditions
• Sample startup files
• C Shell Searchpath
• Bourne shell and C shell paths
• When to change searchpaths
• Undoing any changes
• Summary
• Sidebar
• Optimizing the C Shell Searchpath
• Programs to Optimize the Searchpath
• Programs to measure your efficiency
• Specifying system-specific searchpaths
• Understand directories characteristics.
• Define a consistent naming convention.
• Define a strategy.
• Reduce the complexity.
• Use local link/caching directories.
• Consider a local home directory
• Customizing your environment
• C Shell History - Forward into the Past
• Prehistoric History
• Enabling History
• Automatic History Saving
• Changing your prompt
• Repeating Past Commands
• Repeating older commands
• Appending to a previous command
• Using history to reuse words
• !* - All of the arguments
• !% - find the word
• Editing the last command
• Word Modifiers in History
• Word events
• Numeric word events
• :- - Ranges of words
• Events, words, arguments, aliases
• Variable Modifiers
• :p - Print modifier
• :s - Substitute modifier
• :& - Repeat substitution
• :q - Quote modifier
• :x - Quotes with spaces
• :u and :l - Upper and Lower Case
• The End of History?
• C shell Aliases
• Advantages and disadvantages of C shell aliases
• A file for aliases
• Disabling aliases
• Alias with pipes
• Arguments to aliases
• Redefining commands
• Multiple-line aliases
• Directories and the C shell
• cdpath - favorite directories
• Variables
• Specifying the current directory
• chdir versus cd

Copyright 2001 Bruce Barnett and General Electric Company

All rights reserved

You are allowed to print copies of this tutorial for your personal use, and link to this page, but you are not allowed to make electronic copies, or redistribute this tutorial in any form without permission.

This section describes C shell programming. It covers conditional testing, control loops, and other advanced techniques.

Novice: How do I do XYZ using the C shell?

Expert: You shouldn't use the C shell. Use the Bourne shell.

Novice: I try to, but I get syntax errors.

Expert: That's because you are using the C shell. Use the Bourne shell.

Novice: I've now using the Bourne shell. How to I create aliases and do command-line editing in the Bourne shell?

Expert: You can't. use bash, ksh or tcsh.

Novice: I don't have these shells on all of the systems I use. What can I use?

Expert: In that case, use the C shell.

Novice: But you told me I shouldn't use the C shell!?!

Expert: Well, if you have to, you can use the C shell. It's fine for interactive sessions. But you shouldn't use it for scripts.

Novice: It's really confusing trying to learn two shells at once. I don't know either shell very well, and I'm trying to learn JUST enough to customize my environment. I'd rather just learn one shell at a time.

Expert: Well, it's your funeral.

Novice: How do I do XYZ using the C shell?

Another Expert: You shouldn't be using the C shell. Use the Bourne shell.

Novice: @#%&!

C shell problems

Quoting long strings, $ and !

echo "This quote doesn't end

There are some other strange quoting problems. Like the Bourne shell, the C shell has three ways to quote characters. You can use the single quote, double quote and backslash. But combine them, and find some strange combinations. You can put anything inside single quotes in a Bourne shell script, except single quotes. The C shell won't let you do that. You can type

echo hi!

echo 'hi!'

echo 'hi!'

echo money$

echo "money$"

echo "money$"

The ad hoc parser

if true; then echo yes; fi

if true
then
echo yes
fi

echo abc | while read a
do
echo a is $a
done >/tmp/f1

The C shell does not have a true parser. Instead, the code executes one section for the if command, and another for the while command. What works for one command may not work for another. The if command above cannot be done in the C shell. There are two file redirections, and the C shell can't do either. Also, in the C shell, certain words must be the first word on the line. Therefore you might try something that works with one command, only to discover that it doesn't work on other commands. I've reported a lot of bugs to Sun, and to their credit, many have been fixed. Try the same code on other systems, however, and you might get syntax errors.

The parsing problem is also true with shell built-in commands. Combine them, and discover strange messages. Try the following C shell sequence:

time | echo

time | /bin/echo

Reading one line at a time

File redirection

Signals, Traps and child processes

A time bomb

Tick.... Tick... Tick...

Quoting C Shell Meta-Characters

Like all shells, the C shell examines each line, and breaks it up into words. The first word is a command, and additional words are arguments for the command. The command

more *

more a b

These meta-characters are an integral part of UNIX. Or rather, an integral part of the shell. A meta-character is simply a character with a special meaning. The file system doesn't really care about meta-characters. You can have a filename that contains a space, or an asterisk, or any other character. Similarly, you can specify any meta-character as an argument to any command. Understanding which characters are meta-characters, what they do, and how to prevent them from being special characters is a skill that must be learned. Most learn by trial and error. Trouble is, the C shell is trickier than other shells.

One way to discover these characters is to use the echo built-in command, and see which characters the C shell will echo, and which ones are treated special. Here is the list of meta-characters, and a quick description of the special meaning.

+-----------------------------------------------------------------------+
|		    List of C Chell Meta-Characters			|
+-----------------------------------------------------------------------+
|Meta-character	  Meaning						|
+-----------------------------------------------------------------------+
|newline	  End of command					|
|space		  End of word						|
|tab		  End of word						|
|!		  History						|
|#		  Comment						|
|$		  Variable						|
|&		  End of command arguments, launch in background	|
|(		  Start sub-shell					|
|)		  End sub-shell						|
|{		  Start in-line expansion				|
|}		  End in-line expansion					|
||		  End of command arguments, Pipe into next command	|
|<		  Input Redirection					|
|>		  Output Redirection					|
|*		  Multi-character Filename expansion (a.k.a. globbing)	|
|?		  Single-character Filename expansion (a.k.a. globbing) |
|[		  Character Set Filename expansion (a.k.a. globbing)	|
|]		  Character Set Filename expansion (a.k.a. globbing)	|
|;		  End of command					|
|'		  Strong quoting					|
|"		  Weak quoting						|
|`		  Command substitution					|
|		  Sometimes Special					|
+-----------------------------------------------------------------------+

If you do not want one of these characters to be treated as a meta-character, you must quote it. Another term for this is escape, as in "escape the normal behavior." The Bourne shell has a predictable behavior for quoting meta-characters:

1. Put a backslash before each character.
2. Put single quotes around all of the characters.
3. Put double quotes around all of the characters. Exceptions: the dollar sign ($) and back-quote (`) are special, but a back-slash before them will escape the special connotation.

   The Bourne shell has an internal flag that specifies when quoting occurs. It is either on or off. If quoting is on, then meta-characters are escaped, and treated as normal. The C shell is similar, yet not identical. As you will see, the quoting mechanism is less predictable. In fact, it has some maddening exceptions, Let me elaborate.

Using the backslash

rm a b

Strings in single quotation marks

rm 'a b'

echo 'Hello!'

echo 'Hello!'

echo 'New line ->
'

echo 'New line ->
'

Strings in double quotation marks

rm "a b"

echo "I am $USER"
echo "The current directory is `pwd`"

echo "Hello!"

echo "$HOME"

/home/barnett

+--------------------------------------------------------------+
|	   Meta-character interpretation in strings	       |
+--------------------------------------------------------------+
|Meta-character	  "..."	       '....'	    no quotation marks |
+--------------------------------------------------------------+
|newline	  Requires    Requires    Requires 	       |
|space		  Quoted       Quoted	    Requires 	       |
|tab		  Quoted       Quoted	    Requires 	       |
|!		  Requires    Requires    Requires 	       |
|#		  Quoted       Quoted	    Requires 	       |
|$		  Impossible   Quoted	    Requires 	       |
|&		  Quoted       Quoted	    Requires 	       |
|(		  Quoted       Quoted	    Requires 	       |
|)		  Quoted       Quoted	    Requires 	       |
|{		  Quoted       Quoted	    Requires 	       |
|}		  Quoted       Quoted	    Requires 	       |
||		  Quoted       Quoted	    Requires 	       |
|<		  Quoted       Quoted	    Requires 	       |
|>		  Quoted       Quoted	    Requires 	       |
|*		  Quoted       Quoted	    Requires 	       |
|?		  Quoted       Quoted	    Requires 	       |
|[		  Quoted       Quoted	    Requires 	       |
|]		  Quoted       Quoted	    Requires 	       |
|;		  Quoted       Quoted	    Requires 	       |
|'		  Quoted       Impossible   Requires 	       |
|"		  Impossible   Quoted	    Requires 	       |
|`		  Impossible   Quoted	    Requires 	       |
|		  Quoted       Quoted	    Requires 	       |
+--------------------------------------------------------------+

To use the table, imagine you have a file with the same name as a meta-character. Suppose the filename was "?" (a question mark). You have three methods of specifying the exact filename when deleting it:

rm "?"
rm '?'
rm ?

rm "!"
rm '!'
rm !

Solving special cases

echo "'"
echo '"'

rm "a b"
rm a" "b
rm "a "b
rm a" b"
rm "a"" ""b"
rm "a"' '"b"

Now suppose you want to include a double quote inside a double quote? You can't. But you can switch the types of quotation marks at any point. The last example switches the quotation marks from double quotes to single quotes. This same technique can be used to delete a file with a double quote in the filename. Here are fours ways to do this:

rm 'a"b'
rm a'"'b
rm a"b
rm "a"'"'"b"

echo "The date command returns " '"' `date` '"'
echo 'Here is a single quote:' "'"

Passing variables inside a string

awk '{print $1}'

awk '{print $'$1'}'

C shell Globbing

One of the primary functions of a shell is to provide an easy way to execute commands, and passing several files to the command. Before the shell determines which command to execute, it evaluates variables, and performs filename substitutions. This is a fancy way of saying you can abbreviate filenames. The Bourne shell only supports globbing. The C shell supports three forms of filename substitutions: globbing, in-line expansion, and home directory expansion:

Globbing

ls *

ls `glob *`

Needless to say, after creating, editing, printing, and deleting globs of files day after day, someone realized that life would be easier if the shell did the globbing automatically. And lo, UNIX shells learned to glob.

The C shell has this feature of course. The easiest way to learn how globbing works is to use the echo command:

echo *

echo * .*

echo a* b* c*

echo c* b* a*

If you want, you can enable or disable globbing. The command

set noglob

unset noglob

set noglob
echo a* b* c*
echo 'a* b* c*'

What happens if you type the command

echo Z*

myscript Z*

No match

set nonomatch

You should also note that the asterisk can be anywhere in a filename, and you can use any number of asterisks. To match files that have the letters a, b and c in sequence, use

echo *a*b*c*

Match a single character

echo ???

echo ???*

Matching character sets

echo a* b* c*
echo [abc]*
echo [a-c]*

echo [a-zA-Z]*
echo [abcdefghijklmnopqrstuvwxyzA-Z]*
echo [ABCDEFGHIJKLMNOPQRSTUVWXYZa-z]*
echo [zyxwvutsrqponmlkjihgfedcbaA-Z]*
echo [A-Zzyxwvutsrqponmlkjihgfedcba]*

echo [c-a]*

echo [c-b-a]*

Combining meta-characters

Part1.bk Part2.bk ... Part10.bk

ls Part?.bk Part10.bk

Part01.bk Part02.bk ...Part10.bk

It is also important to note that the shell evaluates variables before expanding filenames. So you can specify

echo $USER??.out

In-line expansion

echo b[012]

b0

echo b{0,1,2,3,0}

b0 b1 b2 b3 b0

echo [b]{0,1,2,3,0}

b0

echo b* b?
echo b{*,?}

echo A1B A22B A333B
echo A{1,22,333}B

echo {0,1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9}

Home directory expansion

more ~smith/.login

C Shell Variable Usage

set myvariable = word
set myvariable = "a string"

set myvariable = ""

unset myvariable

Passing arguments to a shell script

How can you check the number of arguments? The C shell has a second way of specifying the arguments passed to the shell script, using a predefined variable list, called "argv" The C shell borrowed this concept from the C programming language. Wonder why? (Hint: it is called the "C" shell for a reason.) The value $argv[1] is equivalent to $1, and $argv[2] is the same as $2. Furthermore, $argv[*] is equivalent to $*. The variable $#argv contains the number of arguments passed to the shell:

#!/bin/csh
echo There are $#argv arguments
echo First argument is $argv[1], second argument is $argv[2]
echo All of the arguments are $argv[*]

Click here to get file: Csh2.csh
There is a subtle difference between $2 and $argv[2]. If there is only one parameter, the line

echo Second argument is $2

Second argument is

echo Second argument is $argv[2]

Subscript out of range

echo All of the arguments but the first are $argv[2-$#argv]

echo All of the arguments but the first are $argv[2-*]
echo All of the arguments but the first are $argv[2-]

echo first through third arguments are $argv[1-3]

Variables are allowed inside square brackets.

set first = 1
set last = $#argv
echo first argument is $argv[$first]
echo last argument is $argv[$last]
echo all of the arguments are $argv[$first-$last]

Arguments generalized as array lists

set mydate = `date`
# returns a date, like
# Tue Jan 7 17:26:46 EST 1997
echo Month is $mydate[2], year is $mydate[$#mydate]

The C shell does not elegantly handle variables that contain spaces. There is no equivalent to the $@ variable. Consider this:

set a = "1 2 3"
set b = $a

How can you copy an array? The command below should work, but doesn't:

set copy = $argv[*]

set copy = "$argv[*]"

set copy = ( $argv[*] )

set mydate = `date`
set mydate = ( `date` )

set c = $*
set c = $argv[*]
set c = a b
set c = "a" "b"
set c = `date` `date`
set c = `date` $a "b c"

set c = ( $* )
set c = ( $argv[*] )
set c = ( a b )
set c = ( "a" "b" )
set c = ( `date` `date` )
set c = ( `date` $a "b c" )

set b[1] = "$a[1]"
set b[2] = "$a[2]"
etc.

In general, the C shell is not suited for variables that contain spaces. Also, if there is any possibility that an argument contains a space, you should use

set a = ( $argv[1] )

set a = "$argv[1]"

set a = $argv[1]

Clearing array lists

set a = ""

set a = ()

unset a

Testing for variable existence

The Shift command

set a = ( a b )
shift a
# same as
# set a = ( b )

C Shell Flow Control

We've been talking about variables, lists, and strings. Time to start doing something useful with the C shell. Let's start with a simple way to branch.

myprogram && echo The program worked

myprogram || echo the program failed

myprogram && echo program passed | echo program failed

myprogram >/dev/null && echo program passed

myprogram >& /dev/null && echo program passed

echo MATCH | prog

BEFORE
MATCH

echo no | prog

no
AFTER

The C shell has some similarities to the Bourne shell. In fact, the above script could be a Bourne shell script. The two shells act the same in this case. However, early versions of the C shell had a bug. The meaning of "&&" and "||" were reversed. This was a long time ago, and I think most versions of the C shell have this bug fixed. Still, it may not be portable. The second difference between the shells is the Bourne shell allows the curly braces to be used as well as the parenthesis. The parenthesis causes an extra shell to be executed. So the script above requires 4 shells to be executed. The Bourne shell could do it with one shell process. Still, I find it amusing that the above script works for both the C shell and the Bourne shell. But I don't get out much.

The second mechanism for doing tests in the C shell uses the "if" command. There are two formats, a short form and a long form:

# first the short form
if ( expression ) command
# then the long form
if ( expression ) then
command
endif

if (1) echo yes
if (-1) echo yes
if (2) echo yes

if ( `myprogram` ) then
echo yes
endif

if (`echo`) echo no
if (`echo 0`) echo no
if (`echo ""`) echo no
# Only the next statement is true:
if (`echo 1`) echo yes

true && echo yes
myexit 0 && echo yes
if (1) echo yes

if ( { myprogram } ) echo myprogram worked

if ( { grep pattern file >/dev/null } ) echo found pattern

Optional forms of the if command

if (1) (echo a;cat) # an error

if ($debug) then
echo debug mode
else if ($verbose) then
echo verbose mode
else
echo "normal mode"
endif

Problems with the if command

if (1) (echo a;cat) # an error

Suppose you wanted to optionally empty a file, removing all contents. You might try the following:

if ($empty) echo "" >file

You can nest "if" statements inside "if" statements, but combining long and short forms doesn't always work. Notice a pattern? I personally avoid the short form, because if I add an "else" clause, or a nested "if" statement, I get a syntax error.

The next problem is more subtle, but an indication of the ad hoc parsing done by the C shell. The commands that deal with flow control must be the first command on the line. As you recall, the Bourne shell specifies commands have to be on a new line, but a semicolon works as well as a new line. The C shell requires the command to be the first word. "So what?" you may ask. You may have never experienced this problem, but I have. Try to pipe something into a conditional statement. The C shell won't let you do this without creating another script.

The While command

while (1)
lpq
sleep 10
end

As for problems, it's hard to use the C shell to read a file one line at a time.

The Foreach command

# remember the shell expands meta-characters
foreach file ( A*.txt B*.txt )
echo working on file $file
# rest of code
end

# here is another example
foreach word ( `cat file|sort` )
echo $word is next
# rest of code
end

The Switch statement

Complex Expressions

+-----------------------------------+
	    |Operator	  Meaning		|
	    +-----------------------------------+
	    |(...)	  Grouping		|
	    +-----------------------------------+
	    |~		  One's complement	|
	    +-----------------------------------+
	    |!		  Logical negation	|
	    +-----------------------------------+
	    |*		  Multiplication	|
	    |/		  Division		|
	    |%		  Remainder		|
	    +-----------------------------------+
	    |+		  Addition		|
	    |-		  Subtraction		|
	    +-----------------------------------+
	    |<<	  Bitwise shift left	|
	    |>>	  Bitwise shift right	|
	    +-----------------------------------+
	    |<	  Less than		|
	    |>	  Greater than		|
	    |<=	  Less than or equal	|
	    |>=	  Greater than or equal |
	    +-----------------------------------+
	    |==		  Equal to		|
	    |!=		  Not equal to		|
	    |=~		  Pattern Match		|
	    |!~		  Pattern doesn't match |
	    +-----------------------------------+
	    |&	  Bitwise AND		|
	    |^		  Bitwise OR		|
	    ||		  Bitwise inclusive OR	|
	    |&&	  Logical AND		|
	    |||		  Logical OR		|
	    +-----------------------------------+

+--------------------------+
		|Expression	   Results |
		+--------------------------+
		|~ 0			-1 |
		|~ 1			-2 |
		|~ 2			-3 |
		|~ -2			 1 |
		|! 0			 1 |
		|! 1			 0 |
		|! 2			 0 |
		|3 * 1			 3 |
		|30 / 4			 7 |
		|30 % 4			 2 |
		|30 + 4			34 |
		|4 - 30		       -26 |
		|512 >> 1	       256 |
		|512 >> 2	       128 |
		|512 >> 4		32 |
		|2 << 4		32 |
		|3 << 8	       768 |
		|4 < 2		 0 |
		|4 >= 2		 1 |
		|ba =~ b[a-z]		 1 |
		|7 & 8		 0 |
		|7 ^ 8			15 |
		|15 & 8		 8 |
		|15 ^ 8			 7 |
		|15 ^ 7			 8 |
		|15 | 48		63 |
		|15 | 7			15 |
		|15 && 8	 1 |
		|15 || 8		 1 |
		+--------------------------+

The C Shell also supports file operators, shown in table 3.

+-----------------------------------------------------------+
|Operator      Meaning					    |
+-----------------------------------------------------------+
|-r filename   Returns true, if the user has read access    |
|-w filename   Returns true, if the user has write access   |
|-x filename   Returns true, if the user has execute access |
|-e filename   Returns true, if the file exists		    |
|-o filename   Returns true, if the user owns the file	    |
|-z filename   Returns true, if the file is empty	    |
|-f filename   Returns true, if the file is a plain file    |
|-d filename   Returns true, if the file is a directory	    |
+-----------------------------------------------------------+

Commands that use expressions

set a = ( 1 + 2 )

Also borrowed from the C language is the assignment operators +=, -=, *=, /=, and %=. The expression

@ a %= 4

@ a = $a % 4

@ a++
@ b=$a + 4
@ c*=3
@ c=4 + $b

Examples

if ( -o $file && -r $file ) then
source $file
endif

Notice the for command does not support complex expressions. You can emulate the C language for construct using while. This code fragment counts up to 10 using a list:

foreach i ( 1 2 3 4 5 6 7 8 9 10 )
echo $i
end

@ a = 1
@ MAX=100

# count from 1 to $MAX

while ( $a <= $MAX )
echo $a
@ a++
end

Tricky expressions to test

if ( $argv[1] =~ -r ) echo found it

if ( -r =~ -r ) echo found it

if ( X$argv[1] =~ X-r ) echo found it

Parenthesis in the C shell

if ( $a + 2 > 5 ) echo yes
if ( ( $a + 2 ) > 5 ) echo yes

set i = ( a b c d e f g )
foreach i ( a b c d e f g )
echo $i
end

if ( $x > 2 ) echo yes
while ( $x )
@ $x--
end

(stty 9600;cat file) >/dev/printer

@ x = ( ( $b + 4 ) & 255 ) << 2

if ( ( $b + 4 ) > 10 ) echo yes

Break and continue

Interactive Features of the C shell

Bill Joy's Legacy

When I went to college in the early 70s, programming meant going to the keypunch station and carrying around decks of punch cards. The first time I used an interactive terminal, directly connected to a computer, it was a hard-copy device. A popular interactive terminal at that time was the Teletype. It had a keyboard, and printed on a ugly roll of yellow paper. Some models supported a paper tape reader and paper tape punch. It was a bargain, because one machine was a terminal, printer, and backup device. A complete I/O system in one unit, for less than $10,000!

We had a programmer whose job was to edit paper tapes, punching new holes, and splicing paper. The only device used was a Teletype and a tape splicer. If a mistake was made, the "programmer" would position the paper tape just right, and punch out all of the holes to erase that letter. In case you wondered, this is why the ASCII code for delete is 11111111 in binary. Each "1" corresponds to a hole, and a row of 8 holes corresponded to a deleted character. If you made a mistake, you could "erase" the mistake without starting a brand new tape. Just back up and punch out the error. We felt fortunate when the boss ordered several video terminals, which cost more than a complete PC system nowadays. Editing was done by the terminal, which had memory, and keys with arrow characters. We were truly excited. With our new program, that only worked with our new terminal, and 64K of RAM, and 5 MB of hard disk, we now had a real computer system. I imagine Berkeley had computers of a similar configuration, and was equally excited when they got their first VAX. Trouble was, the default editor, ed, was designed for those old-fashioned hard copy terminals. Ed has a consistent user interface. If you typed something right, it said nothing. If you typed something the program didn't understand, it printed out a single question mark. The authors felt that this was sufficient information, and the interpretation of the error message should be obvious. Nowadays people comment on this statement as proof that UNIX was not originally user-friendly. Wrong! You see, Teletypes were incredibly loud. Teletypes were also incredibly slow. I remember pounding on the keys on a model 33 Teletype. Pounding is the right word. I imagine martial-art students practiced on the keyboard, in their effort attempt to develop strong-as-steel fingers. Alas, I lacked the skill, and the instant I made a mistake, the Teletype let loose a 70 decibel machine-gun rat-a-tat-tat for 5.7 seconds, as it typed "Syntax error, please type command again - you stupid person." Needless to say, this irritated me immensely. When I am irritated, I make mistakes. If the operating systems I used only printed a question mark, the years of electro-shock therapy might not have been necessary.

There must be a better way. There was. Bill Joy decided the standard editor sucked, and wrote an editor that did not require special hardware, and allowed you to see what your file looked like while you were editing it. It was a WYSIWYG editor for ASCII characters. He wrote a library called termcap to go along with his vi editor. Most people forget what a major breakthrough this was. Going through my 1980 edition of the Berkeley UNIX manual, I see that Bill Joy wrote the Pascal interpretor and compiler, along with vmstat, apropos, colcrt, mkstr, strings, whereis, whatis, vgrind, soelim, msgs, and the Pascal modifications to ctags and eyacc. He also wrote a significant part of the virtual memory, demand paging, and page replacement algorithm for Berkeley Unix.

Bill Joy also wrote the C shell. Twenty years later it's easier to find fault in the C shell, compared with current shells. But at the time, the C shell had many new ideas, and many still favor it for interactive sessions. Several years elapsed before the Korn shell was written. And several more years elapsed before it or similar shells became commonly available. I'd like to meet someone who feels they could have done a better a better job that Bill, in the same conditions.

Enough ranting.

C shell File Redirection

+---------------------------------------------------------------+
|Characters	 Meaning					|
+---------------------------------------------------------------+
||		 Pipe standard output to next program		|
||&		 Pipe standard and error output to next program |
|>		 Send standard output to new file		|
|>&	 Send standard and error output to new file	|
|>>	 Append standard output to file			|
|>>&	 Append standard and error output to file	|
+---------------------------------------------------------------+

(program >/dev/null) >& file

The noclobber variable

vi script
chmod +x script
script > script .out

program1 >>log
program2 >>log
program3 >>log
program4 >>lag

Both problems can be prevented very easily. Just set the noclobber variable:

set noclobber

This seems like a great idea, but there are times when this feature gets in the way. You may want to write over an existing file. Or you may want to append to a file, but don't know if the file exists or not. If you want to disable this feature, type

unset noclobber

# Create new file
program >out
# overwrite the same file
program >!out
# append to a file, even if it doesn't exist.
program >>!log

#capture error and standard output
program >&! file
program >>&! log

+--------------------------------------------------------------------------------------+
|Characters	  Noclobber	   Meaning					       |
+--------------------------------------------------------------------------------------+
||		  Doesn't Matter   Pipe standard output to next program		       |
||&		  Doesn't Matter   Pipe standard and error output to next program      |
|>		  Not set	   Send standard output to old or new file	       |
|>		  Set		   Send standard output to new file		       |
|>&	  Not set	   Send standard and error output to old or new file   |
|>&	  Set		   Send standard and error output to new file	       |
|>>	  Not set	   Append standard output to old or new file	       |
|>>	  Set		   Append standard output to old file		       |
|>>&	  Not set	   Append standard and error output to old or new file |
|>>&	  Set		   Append standard and error output to old file	       |
|>!		  Doesn't	   Send standard output to new or old file	       |
|>&!	  Doesn't Matter   Send standard and error output to new or old file   |
|>>!	  Doesn't Matter   Append standard output to old or new file	       |
|>>&!	  Doesn't Matter   Append standard and error output to old or new file |
+--------------------------------------------------------------------------------------+

Safe Aliases

A second modification that Berkeley made was to add the "-i" options to the cp, mv and rm commands. These options warned the user if a file was going to be destroyed. The C shell supported an alias feature that allows you to define new commands. If you type

alias move mv

alias mv mv -i
alias cp cp -i
alias rm rm -i

rm *

C Shell Start-up Files

+-----------------------------------------------+
      |File	  Purpose			      |
      +-----------------------------------------------+
      | .cshrc	  Used once per shell		      |
      | .login	  Used at session start, after .cshrc |
      | .logout	  Used at session termination	      |
      +-----------------------------------------------+

The .cshrc file

#!/bin/csh -f

csh -f script

It is important to understand when these files are sourced. When you execute a program like cmdtool, shelltool or xterm, The value of the SHELL environment variable is used, and that shell is executed. If the shell is the C shell, then the .cshrc file is sourced. If you execute a remote command using rsh, the shell specified in the /etc/passwd file is used. If this is the C shell, then .cshrc is used at the start of the process.

The .login file

cd /tmp
cp /bin/csh -csh
-csh

The .logout file

What goes where?

+-----------------------------------------------------------------+
|Condition		     Files sourced			  |
+-----------------------------------------------------------------+
|Logging on the console	     .cshrc, then .login, finally .logout |
|rlogin system		     .cshrc, then .login, finally .logout |
|rsh system		     .cshrc, then .login, finally .logout |
|rsh system command	     .cshrc				  |
|csh filename		     .cshrc				  |
|csh -f filename	     -					  |
|C shell Script without -f   .cshrc				  |
|C shell Script with -f	     -					  |
|Starting a new shell	     .cshrc				  |
|Opening a new window	     .cshrc				  |
+-----------------------------------------------------------------+

The tricky part about start-up files

1. Determining which commands are the ones you want to execute. You discover a useful setting, and want to add this feature to all sessions.
2. Learning when you want to execute these commands. Does this feature need to be set once, or for every shell?
3. Executing commands at the wrong time. Some people put "biff y" in their .cshrc file. This is wrong. It should be in the .login file.
4. Learning when the two files are sourced, and in which order. Some people think the .login file is executed before the .cshrc file. This seems logical, because the .login file is executed during login, but it is wrong. The .cshrc file is always sourced before the .login file.
5. Bloat. Don't add commands without thinking of where they go. Placing commands and options in the wrong place, may be meaningless, and slow down your shell.

All of these problems confound the new C shell user. So how can you distinguish between these different cases? Well, the C shell sets various variables under different conditions. The operating system also has variables, independent of the shell. I'll briefly describe the difference, and provide a template.

The C shell prompt variable

if ( $?prompt == 0 ) then
# This is a shell script
else
# This is interactive
endif

if ( $?prompt ) then
...
...
# 300 lines later
endif

if ( ! $?prompt ) exit
if ( -f ~/.aliases ) source ~/.aliases

The current terminal

if ( "`tty`" =~ "/dev/console" ) then
# start up the window system
/usr/openwin/bin/openwin
endif

Local variables vs. Environment variables

Environment variables are exported to all sub-shells. That is, if you set an environment variable, and then create a new shell, the new shell inherits the value of this variable. Inherit is the essential concept. The child can inherit the traits of the parent, but anything the child does to itself does not affect the parent. If you specify an environment variable before you start up the window system, then all new shells, i.e. all new windows, will inherit the environment variables from the parent shell. But if you set an environment variable to a different value in each window, this has no effect on the parent process, which is your login shell.

You can set environment variables in your .cshrc file. However, this is unnecessary, because any variable set in the .login file will be inherited by all sub-shells. There are two reasons you need to set an environment variable in the .cshrc file. The first is because you need to customize it for each shell. Perhaps different windows have different values. The second reason is that you need to look up something, by executing a program, and want to optimize your shell, so that this only has to be done once. Suppose you wanted to learn what your current computer is called. You could use the following test:

if ( "`hostname`" =~ "grymoire" ) then
...
endif

if ( ! $?HOSTNAME ) then
setenv HOSTNAME `hostname`
endif

Other conditions

# if the terminal type is an HP terminal,
# change the delete character
if ( $TERM =~ "hp*" ) then
stty erase '^h'
endif

Sample startup files

# Sample C shell .login file
# Created by Bruce Barnett
# This file is sourced after .cshrc is sourced
# set up the terminal characteristics
if ( -f ~/.terminal ) source ~/.terminal
# define the environment variables
if ( -f ~/.environment ) source ~/.environment
# set search path
if ( -f ~/.path ) source ~/.path

# Start up window system, but first, learn the terminal type once
if ( ! $?tty ) then
set tty = `tty`
endif

# You may wish to start a window system
# Here is one way:

if ( "$TERM" =~ "sun*" && "$tty" =~ "/dev/console" ) then
# some people like to wait 5 seconds
# echo "starting window system in 5 seconds"
# sleep 5;

# By using 'exec', then when you exit the window system,
# you will be logged out automatically
# without the exec, just return to the shell
/usr/openwin/bin/openwin
# exec /usr/openwin/bin/openwin

# - any more window systems?
# elsif ( $TERM =~ "abc*" && "$tty" =~ "/dev/console" ) then
# start up another window system

endif

C Shell Searchpath

An essential part of Shell Mastery is understanding what a searchpath is, and how to optimize it. Following the principle of modularity, most of the UNIX commands are separate programs. Only a few are built into the shell. This means you can change your shell, and still use 99% of the commands without change. These external programs may be scattered in dozens of directories. When you ask for a command that the shell doesn't understand, it searches the directories in the order specified by the search-path, and executes the first command it finds with the name you specified. And trust me on this, systems that do not behave consistently are bad for your mental health. I knew a programmer who was writing software for a system that behaved unpredictably. He receives excellent care nowadays, but he always asks me the same question. "Two plus two is ALWAYS four, right?" Poor guy. The world will never be safe for programmers until we eliminate all non-deterministic systems.

Bourne shell and C shell paths

PATH=/usr/bin:/usr/ucb:/usr/local/bin
PATH=$PATH:$HOME/bin
EXPORT PATH

setenv PATH /usr/bin:/usr/ucb:/usr/local/bin
setenv PATH ${PATH}:~/bin

The C shell has an alternate way to modify the searchpath, using a list. Here is the same example as before:

set path = ( /usr/bin /usr/ucb /usr/local/bin )
set path = ( $path ~/bin )

set path = ( . $path )

specifies that the current directory is searched for commands before all other directories. Important! This is a security problem. See the sidebar to fully understand the danger of this action.

It might seem confusing that there are two path variables, one in upper case, and the other in lower case. These are not two different variables. Just two different ways to set the same variable. Change one, and the other changes.

Because the C shell uses a list, this allows some convenient mechanisms to examine and manipulate the searchpath. For instance, you can add a directory to the third place of a searchpath using

set path = ( $path[1-2] ~/new $path[3-] )

Here is the same script using the Bourne shell:

#!/bin/sh
# A simple version of which that prints all
# locations that contain the command
file=${1:-"Wrong number of arguments - usage: 'which command'"}
paths=`echo $PATH | sed '
s/^:/.:/g
s/:$/:./g
s/::/:.:/g
s/:/ /g
'`
for dir in $paths
do
[ -x $dir/$file ] && echo $dir/$file
done

Click here to get file: Which.sh
As you can see, the Bourne shell is much more complicated. Surprisingly, my measurements show the Bourne shell version is faster. Well, I found it surprising. I expected the C shell version to be faster, because it doesn't use any external programs. The Bourne shell version executes three additional processes because of the back quotes. Therefore four programs compete with one C shell script. And the C shell still loses. Hmmm. Does this tell you something?

The system comes with a C shell script called "which." Not only does it find the first reference, but it reports if the command is an alias. This is fine, but I prefer the above script, because it tells me about all of the commands, and runs much faster. I called it "Which," with a capital "W," so I can use either one. The Korn shell has a build-in command, called "whence."

When to change searchpaths

if ( ! $?OPENWINHOME ) then
setenv OPENWINHOME /usr/openwin
endif

set path = ( $path $OPENWINHOME/bin )

$OPENWINHOME/bin/openwin

set mybin = ( ~/bin )
set standardbin = ( /usr/ucb /usr/bin /bin )
if ( $?OPENWINHOME ) then
set winpath = ( $OPENWINHOME/bin )
else
set winpath = ( )
endif
# extra lines omitted
set path = ( $mybin $standardbin $winbin )

I start my window system like this:

#!/bin/csh -f
# start OpenWindows
setenv OPENWINHOME /usr/openwin
source ~/.path
$OPENWINHOME/bin/openwin

Click here to get file: OpenWin.csh
This way I have one place to change my searchpath for all conditions. Any time I want to, I can define or undefine variables, and source the same file to reset my path. This allows me to use different windowing systems, or different versions, and have one main file to control my search-path.

Another way I change my searchpath is with an alias. You may want to define the following aliases:

alias .path 'set path = ( . $path )'
alias poppath 'set path = ( $path[2-] )'

You can make aliases as simple or as complicated as needed. For instance, you can radically change your environment with the simple

alias newstuff "source ~/.anotherpath"
alias newwin "source ~/.anotherpath;cmdtool&"

Undoing any changes

csh

Summary

1. Explicitly set the path.
2. Specify it in your .cshrc file.
3. Specify it in your .login file, or before you start the windowing system.
4. Specify it in another file, and source this file.
5. Execute a shell script that changes the path, and then executes another program or shell.
6. Use an aliases to do any or all of the above.

   No one method is right for everyone. Experiment. But don't think you have to set your searchpath in your ".cshrc" file. Other solutions are possible. In fact, next month, I will discuss how to optimize your searchpath.

Sidebar

echo $path

/bin/rm $HOME/*

cd /tmp
ls

If you must include the current directory in your searchpath, put it at the end:

set path = ( $path . )

Personally, I don't have the current directory in my searchpath. It was painful at first, but I soon learned how to adjust. When I want to execute a command in the current directory, I just type

./command

cp command ~/bin

Is that so hard? I sleep much better at night.

Optimizing the C Shell Searchpath

Last month I discussed various ways to modify your C shell searchpath. This month, I will discuss ways to optimize your path.

What do I mean by optimization? Well, to tell the truth, I have looked at a lot of C shell start-up files, and I shudder at what I see. Some people have dozens of directories in their searchpath. I also see people walking around with a gloomy look, as if a storm cloud is circling over their head.

"What's the matter?" I ask.

"My file server is down. I can't get any work done." they reply.

"Oh." I reply. "I didn't notice."

And it's true. A server went down, and it didn't bother me at all because it wasn't in my searchpath. When some people discover a directory that contains useful programs, they add it to their searchpath. The searchpath grows and grows, until it becomes so convoluted, no one understands it. That's the wrong thing to do.

You see, I created a special directory that contained symbolic links to files on remote systems. Because the directory is on my local workstation, I am not affected if a server goes down. The only time I have a problem is if I use one of those executables. That process will freeze, but only that process. All I have to do is create a new window, and continue working. I call this a cache dirctory, and I know that isn't the best name for it. A better name ought to be "favored." but what the heck.

I will admit that solving this problem isn't trivial. In fact, I wrote a program to help me figure out what to do. Several programs, as it turns out. Let me describe them.

Programs to Optimize the Searchpath

CreateCacheDir /local/cachebin /public/bin

Programs to measure your efficiency

Directories that don't exist on this system:
/local/bin/SunOS
/usr/etc
You are dependent upon the following systems:
server1, directories: /home/barnett/bin
Directory /usr/X11R6/bin used 2 times (symbolic links: 1)
symbolic links for '/usr/X11R6/bin' are: /usr/X11/bin

Specifying system-specific searchpaths

Understand directory characteristics.
Define a consistent naming convention.
Define a strategy.
Reduce the complexity.
Use local link/caching directories.
Consider a local home directory

Understand directories characteristics.

However, all directories don't have the same characteristics. Here are some of the variations:

·

A directory that contains standard architecture-specific executables. The directory is read-only, and identical on other systems of the same architecture. Example: /usr

·

System-specific configuration files. Typically writable by super-users only. Example: /etc

·

System-specific directory to hold temporary files. Writable by various processes, programs, and users. Often not backed up. Not visible by other systems. Example: /var

·

Same as the above, but backed up frequently. Example: /private

·

Common files shared across multiple groups. Log onto other systems, and see the same files. Example: /home/server/project

·

Directories which contain locally added executables. This may be private to the system. Example: /local

·

Same as above, but containing executables that are shared among several systems of the same architecture. Examples: /usr/local, /project/bin

·

Same as the above, but containing executables and/or data for multiple architectures. Example: /public

As you can see, there are many different characteristics, and every user has to understand the difference. Make sure you understand how the files at your site are organized. Most new workstations have lots of disk space, and it is rare that the systems don't make it available. Users should know if the files are visible to other systems, and if the files are backed up or not.

Some directories are project-related. Executables are only used when working on the project. Other directories, such as "/projects/bin," are used for certain rarely-used functions. These are what I call "optional" directories. If they are missing, you can still do other work. Other directories are mandatory.

Define a consistent naming convention.

Define a strategy.

/home/systemname - Shared system-specific files. Backed up.
/work/Projectname - Project directories.
/private - Local to system, not backed up, unless I do it myself.
/local - Local to current system. Not shared.
~/SunOS/5.5.1/sun4u/bin - Executables for a specific system type

Reduce the complexity.

Use local link/caching directories.

The solution is simple. Create a directory on your local system, that contains symbolic links to the real files. Then remove the original directory from your searchpath, and add the new one. I discussed this in detail last month. But there is one more step.

Consider a local home directory

Having a home directory local to your main computer can increase your efficience, by removing the dependance on other systems. You can have your own directory for executables, for instance.

Customizing your environment

HOSTNAME - The system hostname
SYSTEM - The operating system type
SYSPATH - The standard vendor-supplied directories
WINPATH - Directories used for the window system
MYBIN - Directories that contain my personal executables
LOCALBIN - Where extra executables are kept
CACHEBIN - My local cache directory

set SYSTEM = "FunnyUnix"
set TOTALPATH = ( ~/bin /usr/bin /usr/ucb /usr/local/bin )

Here is another example, names "path.neptune" for a computer called neptune:

set SYSTEM = "SunOS"
set MYBIN = ( ~/bin ~/SunOS/bin )

~/$SYSTEM/$REV/$MACHINE/bin

~/SunOS/5.5.1/sun4u/bin

~/bin
~/SunOS/bin
~/SunOS/5.5.1/bin
~/SunOS/5.5.1/sun4u/bin

set MYPATH = ( ~/bin ~/SunOS_bin ~/SunOS_5.5.1_bin )

C Shell History - Forward into the Past

Prehistoric History

A common sound was the stampede of fingertips, as the Hacker stalked his or her prey - the perfect program. Faster, faster went the fingers, but it was never fast enough. That perfect program was just around the corner, but rarely was it caught.

One hacker, in an effort to go faster still, decided to enhance his shell in such a way that all he had to do was take a tiny step in a direction, and the shell knew what he wanted to do. That hacker added history. And thus was the history mechanism born.

Enabling History

set history = 100

The command "history" will print out the history information. If you specify a number such as 20, it will list the last 20 commands. You can save a series of commands, and read them in later:

history -h 20 >file
... (do something else )
source -h file

Automatic History Saving

set savehist = 10

source -h ~/.history

Changing your prompt

set prompt = '!% '

alias h history

alias h "history 20"
alias H "history 100 | more"

Repeating Past Commands

!!

ls file?
# now rename each of these files
foreach i (`!!`)
mv $i $i.old
end

Repeating older commands

31 vi file1.c
32 make file1
33 ./file1

!31

A third form uses the first few letters of the command. To repeat the vi command, you can use

!v

Suppose you typed the following commands:

make prog1;./prog1
make prog2;./prog2

!m
!ma
!mak
!make

!make prog1

!?prog1?

Appending to a previous command

grep keyword file*
!! | grep -v ignore
!! | sort
!! | more

lpr prog
!!1
# same as
# lpr prog1

!v file2.c

vi File
chmod +x File
./File
cp File File1

!v1

!v 1

!v
!!1

!{v}1

!{-2}
!{32}
!{?File1?}

!{-2}1
!{32}1
!{?File1?}1

Using history to reuse words

touch File
chmod +x !$
vi !$
./!$
cp !$ !$.orig

touch File
chmod +x File
vi File
./File
cp ./File ./File.orig

touch File
cp File File.backup
vi File
chmod +x File
File abc

touch File
cp !^ !^.backup
vi !^
chmod +x !^
!$ abc

!* - All of the arguments

ls *% %~ *.old *.backup
# A lot of files - move them into a directory
mv !* OldDirectory

ls f1 f2 f3 f4 f5 f6 f7 f8 f9
!!-4
# this is the same as
ls f1 f2 f3 f4 f5

!% - find the word

!?ABC?

more A_file_with_a_long_name

!more
lpr !$

history | grep A

# print the command containing "A"
echo !?A?
lpr !$

lpr !?A?%
# same as
# lpr A_file_with_a_long_name

Editing the last command

mroe File

^ro^or^

Someone onced asked me if there was a way to do this with a function key. They kept pressing the backquote by mistake. That is, they typed

ls`

# i.e. csh history
mapi F7 ^`^n

^`^

One more thing, recent versions of Solaris do not require you to type the second up-arrow. If you want to delete the letter "x" from the previous command, just type

^x

Word Modifiers in History

There are three types of history substitutions: events, words, and word modifiers. I discussed event designators last month. These correspond to lines typed at the keyboard. A summary of event designators follows:

+-----------------------------------------------------------+
|Format	  Example   Meaning				    |
+-----------------------------------------------------------+
|n	  !2	    Command from line #2		    |
|-n	  !-3	    Command 3 commands ago		    |
|#	  !#	    The current command			    |
|!	  !!	    The last command			    |
|s	  !abc	    The last command that starts with 'abc' |
|?s?	  !?abc?    The last command that contained 'abc'   |
+-----------------------------------------------------------+

I didn't mention the "!#" event last time. This is a feature of newer versions of the C shell. It matches the current line. It isn't much used unless you use some of the features described below.

long_word !#

long_word long_word

Word events

program arg1 special2 arg3 arg4

+-----------------------------------------------+
      |Character   Example    Value		      |
      +-----------------------------------------------+
      |^	   !^	      arg1		      |
      |*	   !*	      arg1 special2 arg3 arg4 |
      |$	   !$	      arg4		      |
      |%	   !?spec?%   special2		      |
      +-----------------------------------------------+

program arg1 arg2
# now print arg2
lpr !$
lpr !!$
lpr !!:$
lpr !{!:$}
lpr !:$

Numeric word events

lpr !:2

program abc{1,2,3} *.? "a b";program2>file.out

+------------------+
		    |Word   Value      |
		    +------------------+
		    |!:0    program    |
		    |!:1    abc{1,2,3} |
		    |!:2    *.?	       |
		    |!:3    "a b"      |
		    |!:4    ;	       |
		    |!:5    program2   |
		    |!:6    >       |
		    |!:7    file.out   |
		    +------------------+

I've already mentioned that "!!:5" is the same as "!:5" when used to refer to the fifth word of the previous line. Two different syntaxes exist, because you can use these word modifiers to refer to any command stored in the history memory. If the history contained the following command:

cc -o prog prog.c
./prog >A_long_file_name

+-----------------------------+
	       |Modifier    Value	     |
	       +-----------------------------+
	       |!c:2	    prog	     |
	       |!?long?:2   A_long_file_name |
	       +-----------------------------+

:- - Ranges of words

program a b c d e f g h

+---------------------------+
		|Variable   Value	    |
		+---------------------------+
		|!!:2	    b		    |
		|!!:4	    d		    |
		|!!:2-4	    b c d	    |
		|!!:2-	    b c d e f g	    |
		|!!:2-$	    b c d e f g h   |
		|!!:2*	    b c d e f g h   |
		|!!:-	    a b c d e f g   |
		|!!:1-$	    a b c d e f g h |
		|!!:*	    a b c d e f g h |
		+---------------------------+

Events, words, arguments, aliases

compile xyz

cc -o xyz xvz.c

alias compile 'cc -o !:1 !:1.c'

Variable Modifiers

set a = "/a/b/c/d.e.f.g"

+-------------------------------------------------------+
  |Modifier   Meaning		    Example   Results	  |
  +-------------------------------------------------------+
  |r	      Root		    $a:r      a/b/c.d.e.f |
  |e	      Extension		    $a:e      g		  |
  |h	      Head (or Directory)   $a:h      /a/b	  |
  |t	      Tail (or Filename)    $a:t      c.d.e.f.g	  |
  +-------------------------------------------------------+

Earlier, I mentioned how the syntax of the C shell can be complex. These variable modifiers can be used for variables, arguments, history and aliases. Let me give some examples. If you wanted to rename all files with the extension ".old" to the extension ".new," then use

foreach i ( *.old )
mv $i $i:r.new
end

#!/bin/csh -f
cc -o $1:r $i:r.c

alias compile 'cc -o !:1:r !:1:r.c'

diff file.old file

diff file{.old,}

diff file.old !#:$:r

:p - Print modifier

echo !abc

!abc:p

:s - Substitute modifier

#!/bin/csh -f
mv $1 $1:s/old/new/

alias old2new 'mv !:1 !:1:s/old/new/'

The string substituted is not a regular expression. The characters are ordinary. There is one special character, when used in the second pattern - "&." This matches the string in the first part. Suppose you typed

echo abc.{1,2}

echo {abc,def}.{1,2}

^abc^{&,def}

:& - Repeat substitution

cc -o trial trial.c

!!:s^trial^program^

^trial^program

cc -o program trial.c

program abc.1 abc.2 abc.3 abc.4
program def.1 def.2 def.3 def.4

program abc.1 abc.2 abc.3 abc.4
# Now change 'abc' to 'def', but don't execute it
^abc^def^:p
# Now repeat it for each argument
!!:g&

echo a aa aaa aaaa
^a^A^:p
!!:g&

echo A Aa Aaa Aaaa

:q - Quote modifier

# The test_me script, either sh or csh
echo $1

test_me ?

#!/bin/csh -f
set nonomatch
echo $1

#!/bin/csh -f
echo $1:q

:x - Quotes with spaces

test_1 'This is a question?'

#!/bin/csh -f
# This is the test_1 script
test_2 $1:q
# or use
set nonomatch
test_2 "$1"

#!/bin/csh -f
# This is the test_1 script
set nonomatch
test_2 $1

#!/bin/csh -f
test_2 $1:x

:u and :l - Upper and Lower Case

The End of History?

Well, that is everything I know about the history feature of the C shell. It is confusing, but I tried to come up with examples of all of the main features. I hope you found this interesting.

C shell Aliases

If there is something that I do on the computer a lot, I look for ways to make my life easier. If there is something that takes ten seconds to type, I'll do whatever it takes to save nine seconds of those ten, even if it takes me days to accomplish this. Weeks, even. Months. Years. No. Not quite. I'm not compulsive, you know. Don't be silly.

C shell users have a very important tool to save those extraneous seconds: aliases. There are several alternative techniques to save keystrokes. In the last two columns I discussed the history function in detail. You can also create shell scripts. However, shell scripts run in a new shell process. You cannot use them to change your current shell process. Most of you have tried this, by creating a script that says something like:

#!/bin/csh -f
cd newdirectory
setenv VAR `pwd`

myscript;pwd;echo $VAR

The third method is to use variables as commands. Many people forget about this particular approach. The following commands will execute the contents of the C shell script in the current shell, changing the current directory:

set DO = "source ~/bin/myscript"
$DO

alias DO "source ~/bin/myscript"
DO

Advantages and disadvantages of C shell aliases

·

You can save keystrokes.

·

Simple aliases are easy to understand.

·

Changes affect the current shell.

·

Meta-characters can be passed without quoting.

But there are several disadvantages:

·

Complex aliases have a confusing syntax.

·

Certain characters must be quoted to pass them into an alias. This makes the syntax more complex.

·

Aliases are defined on a single line. This makes it difficult to document complex aliases, and multiple-lined aliases must have the newline quoted.

·

Because the C shell syntax requires certain words on the beginning of the line, it is difficult to include commands like while, or foreach in the alias definition. Using these in aliases require additional quoting, adding more complexity.

Bourne shell functions were added long after C shells had the alias. They act like aliases, but do not suffer from the above problems. Instead, Bourne shell functions have the following advantages:

·

Bourne shell functions have the same syntax as shell scripts.

·

Bourne shell functions can be easily documented, especially those that are several lines long.

·

Bourne shell functions don't require additional quoting, and the quoting is more consistant.

All-in-all, the concept of C shell aliases is flawed. They are fine for simple definitions, but if you need anything more complex, I suggest you use a shell script (in whatever shell you prefer) or define an alias to source the script, as I did above.

A file for aliases

if ( -f ~/.aliases && -o ~/.aliases ) source ~/.aliases

if ( ! $?ALIAS_def ) then
if ( -f ~/.aliases && -o ~/.aliases ) source ~/.aliases
endif

set ALIAS_def

alias rm rm -i
alias mv mv -i
alias cp cp -i

Aliases can also abbreviate commands:

alias a alias
# create aliases for "more" and "emacs"
a m more
a e emacs

alias lf ls -F
alias la ls -a
alias li ls -i
alias ll ls -l
# yada yada...

lf A*
ll *.c

Disabling aliases

unalias rm mv cp

rm file*
"mv" file1 file2
""cp new old

alias ll ls -l
alias llF ll -F

alias AA BB
alias BB AA

Alias with pipes

# do an ls -l, but only list directories
alias ldir 'ls -l|grep "^d"'

biggest [A-Z]*

ls -lut | head -30 [A-Z]*

Arguments to aliases

# sort by date:
alias newest 'ls -lt !* | head -30'
alias oldest 'ls -ltr !* | head -30'

% findfile test*
-rw-r--r-- 1 barnett staff 22027 Nov 9 23:32 ./test.pl
-rw-rw-r-- 1 barnett staff 18520 Aug 26 12:13 ./Old/test.out
-rwxrwxr-x 1 barnett staff 18557 Sep 12 09:43 ./Tmp/test.sort

findfile test*
or
findfile 'test*'

You can reuse a single argument. Here is an alias I use when I want to work on a copy of a file, and leave the original alone, keeping the date the same:

alias orig "mv !:1 !:1.orig;cp !:1.orig !:1"

mv file.c file.c.orig
cp file.c.orig file.c

Compiling C programs can be complex, especially if you do not have a makefile to go with it. Here are some that can be used to compile C programs:

alias ccc 'cc -o !:1:r !*'
alias ccg 'cc -g -o !:1:r !*'
alias cco 'cc -fast -o !:1:r !*'
alias ccx 'cc -o !:1:r !* -L${OPENWINHOME}/lib -lX11

ccg main.c part1.c part2.c

alias slay 'set j=`/usr/ucb/ps -ax| grep !*|head -1`;
kill -9 `echo $j[1]`'

You can pick and choose the arguments you want. If you wanted an alias to move to a directory, with the directory as the first argument, use

# as in
# moveto directory *.c
alias moveto 'mv !:2* !:1'

+----------------------------------+
	    |	     Aliases arguments	       |
	    +----------------------------------+
	    |Variable	meaning		       |
	    +----------------------------------+
	    |!:1	Argument 1	       |
	    |!:2	Argument 2	       |
	    |!*		Arguments 1 through n  |
	    |!:1-$	Arguments 1 through n  |
	    |!:1*	Arguments 1 through n  |
	    |!$		Nth argument	       |
	    |!:-	Argument 1 through n-1 |
	    |!:2-	Argument 2 through n-1 |
	    |!:2-$	Argument 2 through n   |
	    |!:2*	Argument 2 through n   |
	    |!:2-4	Arguments 2, 3 and 4   |
	    +----------------------------------+

Redefining commands

alias cat mycat
alias /bin/cat mycat
alias /usr/bin/cat mycat

alias command '/source ~/.command; /bin/command'

Multiple-line aliases

C file1.f

Error: this is for C programs only
Extension should be .c on file file1.f, not .f

C prog.c file1.c file2.c file3.c

mv prog prog.old
cc -o prog proc.c file1.c file2.c

I have tried to use aliases that use foreach and while commands. To be honest, I find them impossible to write. I suggest you use a shell script if possible. There are, however, times when a shell script doesn't work well. Suppose you want to source several files. You could type

foreach i ( *.alias )
source $i
end

alias FOREACH 'set a = !:1;
set b = (!:2*);
source ~/source_alias/FOREACH.csh;'

#!/bin/echo use source to execute this command
# variable a = filename metacharacter
# variable b = command to execute
foreach i ( $a )
eval $b $a
end

FOREACH *.csh source

Now, for a special treat, (I'm proud of this next trick) I have a more powerful version. Suppose we wanted to take each file, and rename it with a ".old" extension. That is, suppose you type:

FOREACH *.csh mv # #.old

foreach i ( *.csh )
mv $i $i.old
end

Since this is starting to get a bit complex, I combined the definition of the alias with the script itself. You source this file to define the alias. You also source the same file to execute the script. Therefore both parts are in the same file:

#!/bin/echo use source to execute this command
# variable a = filename metacharacter
# variable b = command to execute

# source this to define the alias
if ( ! $?FOREACH_def) then
alias FOREACH 'set a = !:1;
set b = (!:2*);
source ~/source_alias/FOREACH.csh;'
set FOREACH_def
else
echo $b | grep '#' >/dev/null
# remember status
set r = $status
foreach i ( $a )
if ( $r == 0 ) then
# change '#' to $i
set B = `echo $b | sed 's/#/'$i'/g'`
else
# Add a '$i' to the end, if it is missing
set B = `echo $b | sed 's/$/ '$i'/'`
endif
eval $B
end
endif

Click here to get file: Foreach1.csh
This script is upwardly compatable with the previous script. If you typed

FOREACH *.csh source #

FOREACH *.csh source

FOREACHr *.c mv #.c #.old.c

Directories and the C shell

This section talks about the "cd" command. Wait! Come back. Sure, everyone knows this command. It's the first command UNIX users learn. Sounds like an excellent reason to discuss it. Ah, you question my sanity. It's okay. I'm used to it. It's a good topic, because it has subtle abilities and most people are ignorant of them.

Directories and paths are either absolute (starting with "/)" or relative (starting with any other character). The directories "." and ".." are special. The first specifies the current directory, and the second the parent of the current directory. The command

cd ./dir/../dir/../.

If you get lost, or you simply want a quick way to go back to your home directory, the command

cd

Normally, when you start up your window system, each new window starts up with the working directory being the same as the one you were in when you started up the windowing system. However, "cd" with no arguments still takes you to your home directory. Alternately, you can change your home directory:

set home = /usr/project

Your true home directory, or any user's home directory, which is determined by the entries in the "/etc/passwd" file, can be accessed by

cd ~username

cdpath - favorite directories

You may occasionally type the "cd" command and get the error "no such file of directory." Perhaps you forgot which directory you were in, or forgot to add "~/" or "../" before the name. This can be fixed. If you have a set of favorite directory where you normally create new directories, you can specify this set, by setting the variable "cdpath." This variable accepts a wordlist. Example:

set cdpath = ( .. ~/Src /usr/projects ~ )

cd prog

./prog
../prog
~/Src/prog
/usr/projects/prog
~/prog

Variables

set Src = "~/Src"
set p = "/usr/projects"

cd $Src
cd $Src/program
cp $P/data .

cd $P
cd P

Remember that the C shell first looks for the directory in the current directory, then the list in "cdpath," and finally the variable.

This can be used by adding the following alias to your .cshrc file:

alias = 'set !:1=$cwd'

= A

cd A

= A
cd NewDirectory
cp $A/file .

Remember that only "cd" will test for a variable. So commands like

cp A/file .

You can also use aliases. Executing the command

alias projects 'cd /usr/projects'

Specifying the current directory

echo $cwd

alias cwd 'echo $cwd'

cd /usr/tmp; pwd; echo $cwd

/var/tmp
/usr/tmp

set hardpaths

NOTE: what about cd /usr/tmp/..?

The C-shell also provides a convenient method of changing between a common set of directories. It keeps a "directory stack" - which can be displayed with the command

dirs

You can make use of this stack by using the command "pushd" - push directory - instead of "cd." They both change directories, but "pushd" adds your old directory to the stack, and puts the new directory on the top of the same stack.

Here is an example (lines starting with "%" are typed by the user)

% dirs
~
% pushd /usr; dirs; pwd
/usr ~
/usr

popd

"Cd" only changes the top directory. If, therefore, you are in a projects directory, but are interrupted, you can "pushd" to the new directory, and "cd" to several other directories. When you are done, "popd" will return you to the directory before the interruption.

Both "pushd" and "popd" can have an argument consisting of the character "+" followed by a number. "popd" will discard the "nth" entry in the stack, without changing the current directory. "pushd" will change the current directory to the "nth" entry, rotating the entire stack so that entry is now on top.

For instance, if you had the stack

/usr/spool/news/comp/sys /usr/spool/news/comp /usr/spool/news /usr/spool /usr

pushd +2

/usr/spool/news /usr/spool /usr /usr/spool/news/comp/sys /usr/spool/news/comp

Some people like to keep their current stack of directories in an array. This is simple:

alias pushd 'pushd !* && set dirs = (`dirs`)'
alias popd 'popd !* && set dirs = (`dirs`)'

cp $dirs[2]/file $dirs[3]
foreach dir ( $dirs )
if ( -f $ddir/DATA ) echo $dir/DATA found
end

repeat 9 popd

alias +1 pushd +1
alias +2 pushd +2
alias +3 pushd +3
alias -1 popd +1
alias -2 popd +2
alias -3 popd +3

chdir versus cd

Be aware that "cd" is built into the shell. The command "chdir" is a synonym, convenient when creating aliases for "cd." So executing cd in a shell script will not change your current shell's directory. If you want to do some clever things, like changing your prompt to reflect your current directory, you have to use the alias feature. But when the alias is combined with the "source" command in the C-shell, a lot of flexibility is available. But more on that later.

This alias will echo your current directory whenever you change it.

alias cd 'cd !*;echo $cwd'

alias cd 'chdir !*;echo $cwd'

alias cd 'chdir !*; if ( -f .dir && -o .dir ) source .dir '

These aliases allow you to move up and down directories, and the command "." is easier to type, and faster, than "pwd."

alias . 'echo $cwd'
alias .. 'set dot=$cwd;cd ..'
alias , 'cd $dot '

alias cwd echo $cwd

set prompt="! % "

alias SP 'set prompt="! % "'
SP

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

command number
hostname
user
current directory

alias cd 'chdir !*;SP'
alias SP 'set prompt="! `hostname` {$USER} $cwd > "'

alias SP 'set prompt="! `hostname` {$USER} `basename $cwd` > "'

alias SP 'set prompt="! `hostname` {$USER} $cwd:t > "'

instead of the above line.

Some people even use multi-line prompts:

set hostname = `hostname`
alias SP 'set prompt="
${hostname}::${cwd}
! % "'

Next month, I will explain my system for integrating diretory management with the window system. I have used more elaborate aliases that execute programs which provide directory selection from the current stack using cursor keys. But that is beyond this tutorial. Instead, I would like to end with a popular set of aliases that changes the black bar on top of each SunView window to show the current hostname and directory stack. In addition, it adds the following commands:

+---------------------------------------+
	  |Command   Function			  |
	  | _					  |
	  | +	     alias for "pushd"		  |
	  | -	     alias for "popd"		  |
	  | ~	     alias for "cd ~"		  |
	  | .	     update top stripe, show jobs |
	  | ..	     go up one directory	  |
	  | ,	     go back down (used with ..)  |
	  | --	     go to last directory	  |
	  +---------------------------------------+

#!/bin/sh
# Zappath: created by Bruce Barnett
# this script edits the output of the C shell "dirs"
# command and shortens the strings to a compact form
#
# Some example editing:
#
# remove the automount /tmp_mnt prefix
# change /usr/export/home to /home
# change /homedisk to /home
# change $HOME into ~
# change /home/abc to abc
# change /usr/etc to ./etc
# change */*/ABC to ./ABC
# one more thing:
# must change ~ to be -
sed '
s:/tmp_mnt::g
s:/usr/export/home:/home:g
s:/homedisk:/home:g
s:'${HOME}':~:g
s:/home/::g
s:/usr/:./:g
s:[^/ ]*/[^/ ]*/:./:g
s:~:-:g
'

Click here to get file: Zappath.sh


# C shell aliases to display hosts, directories, and directory stacks
# in the window title bar, icon string, and directory prompt
# created by Bruce Barnett
# Based on the SunOS 3.5 Release notes
# Usage:
# if ( -f ~/.header && -f ~/bin/Zappath ) source ~/.header
#
# the SP alias sets the directory prompt
# the setbar alias changes the window title bar and icon string
# define them here as the default case

alias SP 'set prompt="$cwd:t% "'
alias setbar 'echo !* >/dev/null'

# If not a sun cmdtool or shelltool, or not an X terminal, exit.
if ( ! ( $term =~ sun* ) && ! ( $term =~ xterm )) goto getout

# if using a raw console, don't do anything
if ( `tty` =~ /dev/console ) goto getout

# set a few variables for later
# but only if the environment variable is not set

if ( ! $?HOSTNAME ) then
setenv HOSTNAME `hostname`
endif

# find the home machine
# is there a file that has a machine name in it?
if ( -f ~/.display ) then
set mymachine = `sed -e 's/:.*//' <~/.display`
else
# obviously change this to match your
# default system. Mine is "grymoire" - of course
set mymachine = "grymoire"
# alternately, some people use "who am i"
endif

set console = '<< CONSOLE >>'

# figure how how to generate escape, bell,
# and echo commands without a a line terminator
# I may have done this before. If so, the variable E is set

# have I executed this script before on this system?
if ( $?E ) then
# echo "already set the echo variables">/dev/tty
else if ( -f ~/.echo.${HOSTNAME} ) then
source ~/.echo.${HOSTNAME}
else if ( `echo -n |wc -l` == 0 ) then
# echo "built in echo is bsd" >/dev/tty
# then berkeley style echo
echo 'set ech = "echo -n"' >~/.echo.${HOSTNAME}
echo "set E = `echo a | tr a ' 33'`" >> ~/.echo.${HOSTNAME}
echo "set B = `echo a | tr a ' 07'`" >> ~/.echo.${HOSTNAME}
echo 'set N = ""' >> ~/.echo.${HOSTNAME}
source ~/.echo.${HOSTNAME}
else
# echo "built in echo is sysV" >/dev/tty
echo 'set ech = "echo"' >~/.echo.${HOSTNAME}
echo 'set E = " 33"' >> ~/.echo.${HOSTNAME}
echo 'set B = " 07"' >> ~/.echo.${HOSTNAME}
echo 'set N = ""' >> ~/.echo.${HOSTNAME}
source ~/.echo.${HOSTNAME}
endif


# Are we using shelltool, cmdtool or xterm?
# duplicate these aliases here to avoid problems
if ( $term =~ sun* ) then
# Sun Aliases
alias Header '${ech} "${E}]l!:1${E}${N}"'
alias IHeader '${ech} "${E}]L!:1${E}${N}"'
else if ( $term =~ xterm ) then
alias Header '${ech} "${E}]2;!:1${B}${N}"'
alias IHeader '${ech} "${E}]1;!:1${B}${N}"'
endif

# There are three different combinations:
# 1) A window on a remote machine
# 2) A window on my machine
# 3) A console on my machine

# test for each case:

if (${HOSTNAME} != $mymachine ) then
# it is a remote machine, therefore:
# window title has machinename and dirs
# icon has machine name only
# prompt has machine name+directory

alias setbar 'Header "${HOSTNAME}: `dirs | ~/bin/Zappath`" ; IHeader ${HOSTNAME}'

# use either of these two lines to suit your tastes
# the first one shows the command number and full directory path
# The second shows just the hostname and the tail of the directory name

# alias SP 'set prompt="[!] ${HOSTNAME}:$cwd % "'
alias SP 'set prompt="${HOSTNAME}:$cwd:t% "'

else if ( `tty` == "/dev/console" ) then
goto getout
else if ( `tty` == "/dev/ttyp0" ) then

# in this case an assumption is made that the first pty
# window to appear is the console window.
# It's not always true, but it usually works

# window title has <> and dirs
# icon has "console" only
# prompt has directory

alias setbar 'Header "${console} `dirs | ~/bin/Zappath`"'

# both of these works - pick one that suits you
# alias SP 'set prompt="[!] $cwd % "'
alias SP 'set prompt="$cwd:t% "'
else
# a plain window on my localhost
# window title has dirs
# icon has cwd only
# prompt has directory
# The next line must be one line, and not split onto two
alias setbar 'Header "`dirs | ~/bin/Zappath `"; IHeader "`echo $cwd| ~/bin/Zappath`"'
# alias SP 'set prompt="[!] $cwd % "'
alias SP 'set prompt="$cwd:t% "'
endif

# redo current window
alias . 'dirs|~/bin/Zappath;setbar;jobs'

# change cd to change prompt, window and icon title
alias cd 'chdir !*; SP;setbar'
alias pushd 'pushd !*; SP;setbar'
alias popd 'popd !*; SP;setbar'

SP;setbar
getout:
# end

Click here to get file: Header.csh

This document was translated by troff2html v0.21 on September 22, 2001.