csh(C)

Syntax

Description

The shell repeatedly performs the following actions: a line of command input is read and broken into words. This sequence of words is placed on the command history list and then parsed. Finally, each command in the current line is executed.

When a login shell terminates, it executes commands from the file .logout in the user's home directory.

Lexical structure

In addition, strings enclosed in matched pairs of quotations, (`, ´ or "), form parts of a word; metacharacters in these strings, including blanks and tabs, are not treated as separate words. The semantics of quoted strings are described below. Within quoted strings delimited by pairs of (´) or (") characters, a newline preceded by a ``\'' gives a true newline character.

If the shell reads the character ``#'' in its input, it treats the rest of the current line (that is, all the text to the right of the ``#'') as a comment, and ignores it. The ``#'' character loses this special meaning if it is preceded by a backslash character (\) or placed inside quotation marks (`, ´, or ").

Commands

Any of the above commands may be placed in parentheses to form a new simple command (which in turn may be used as a component of a pipeline or some other more complex command). It is also possible to separate pipelines with the ``&&'' or ``||'' expressions: these stand for logical-OR and logical-AND respectively. (Due to an historical bug, csh assigns these symbols the opposite meaning to that assumed by the C programming language and other UNIX^® utilities.) Use of these expressions makes the execution of the second pipeline conditional upon the success (logical-AND) or failure (logical-OR) of the first. (See ``Expressions'' for more information.)

Substitutions

History substitutions

History substitutions begin with the character ``!'' and may begin anywhere in the input stream unless a history substitution is already in progress. A ``!'' preceded by a backslash (\), or followed by a space, tab, newline, ``='' or ``('', is treated as a literal ``!'' and its special meaning is suppressed. History substitutions may also occur when an input line begins with ``^''. This special abbreviation is described later.

The text of any input line containing a history substitution is echoed on the terminal after the substitution has been carried out, so that the user can see the literal command that is being executed.

Commands entered at the terminal and consisting of one or more words are saved on the history list, the size of which is controlled by the history variable. The previous command is always retained. Commands are assigned numbers incrementally, starting with 1 (the first command executed under the current csh).

For example, enter the command:

history

This internal command causes csh to print a list of the commands stored on the history list, along with their event numbers. Now, consider the following (sample) output from the history command:

    9  write michael
   10  ex write.c
   11  cat oldwrite.c
   12  diff *write.c

If the current event (the current command line) is 13, we can refer to previous command lines in several ways:

By event number:

!11

to re-run cat oldwrite.c

By relative event number:

!-2

to go back two events; this will also re-run cat oldwrite.c

By part of a command:

!d

to re-run the most recent command starting with a ``d'', in this case diff *write.c, or:

!?mic?

to re-run the most recent command containing the string ``mic'', write michael

These forms simply reproduce the words of the specified event, each separated by a single blank. The special case ``!!'' refers to the previous command; thus the history substitution ``!!'' means ``repeat the last command.'' The form ``!#'' references the current command (the one being entered on the current line). It allows a word to be selected from further left in the line, for example to avoid retyping a long name, as in ``!#:1''.

To select words from an event, we can follow the event specification by a colon (:) and a designator for the desired words. The words of an input line are numbered from 0, the first (usually command) word being 0, the second word (first argument) being 1, and so on. The basic word designators are:

0

first (command) word

n

nth argument

^

first argument, that is, 1

$

last argument

%

word matched by (immediately preceding) ?s? search

x-y

range of words

-y

abbreviates 0-y

abbreviates ^-$, or nothing if only 1 word in the event

x

abbreviates x-$

x-

like x but omitting word $

h

removes a trailing pathname component

r

removes a trailing .xxx component

e

returns the trailing .xxx pathname component

s/l/r/

substitutes r for l

t

removes all leading pathname components

&

repeats the previous substitution

g

applies the change globally, prefixing the above

p

prints the new command but does not execute it

q

quotes the substituted words, preventing substitutions

x

like q, but breaks into words at blanks, tabs, and newlines

The left sides of substitutions are not regular expressions like those recognized by the editors, but rather strings. Any character may be used as the delimiter instead of ``/''; if it is necessary to include an instance of the delimiter character within one of the substitution strings, its special meaning may be removed by preceding it with a ``\''. An ampersand character (&) in the right side of a substitution is replaced by the text from the left side of the substitution. An ampersand preceded by a backslash (\&) is treated as a literal ampersand (&) with no special meaning. A null l uses the previous string either from an l or from a contextual scan string s in ``!?s?''. The trailing delimiter in the substitution may be omitted if a newline follows immediately, as may the trailing ``?'' in a contextual scan.

A history reference may be given without an event specification (for example, !$). It is assumed that the reference is to the previous command unless a history substitution precedes it on the same line, in which case it is assumed to refer to the last event substitution. Thus !?foo?^!$ gives the first and last arguments from the command matching ?foo?.

A special abbreviation of a history reference occurs when the first nonblank character of an input line is a ``^''. This is equivalent to !:s^, providing a convenient shorthand for substitutions on the text of the previous line. Thus ^lb^lib fixes the spelling of lib in the previous command.

Finally, a history substitution may be surrounded with ``{'' and ``}'' if necessary to insulate it from the characters that follow. Thus, after ls -ld ~paul, the command !{l}a performs ls -ld ~paula, while the command !la looks for a command starting la.

Quotations with ' and ''

In both cases, the resulting text becomes all or part of a single word; only in one special case (see ``Command substitution'' below) does a double quoted string yield parts of more than one word; single quoted strings never do.

Alias substitution

Thus, if the alias for ls is ls -l, the command ls /usr maps to ls -l /usr. Similarly if the alias for lookup is grep \!^ /etc/passwd, then lookup bill maps to grep bill /etc/passwd.

If an alias is found, the word transformation of the input text is performed and the aliasing process begins again on the newly generated input line. Looping is prevented by flagging the first word of the old text; if the first word of the new text is the same, further aliasing is prevented. Other loops are detected and cause an error.

Note that the mechanism allows aliases to introduce parser metasyntax. Thus:

   alias print 'pr :* | lpr'

There are four csh aliases distributed. These are pushd, popd, swapd, and flipd. These aliases maintain a directory stack.

pushd dir

Pushes the current directory onto the top of the directory stack, then changes to the directory dir.

popd

Changes to the directory at the top of the stack, then removes (pops) the top directory from the stack, and announces the current directory.

swapd

Swaps the top two directories on the stack. The directory on the top becomes the second to the top, and the second to the top directory becomes the top directory.

flipd

Flips between two directories, the current directory and the top directory on the stack. If you are currently in dir1, and dir2 is on the top of the stack, when flipd is invoked you change to dir2, and dir1 is replaced as the top directory on the stack. When flipd is again invoked, you change to dir1, and dir2 is again the top directory on the stack.

Variable substitution

The values of variables may be displayed and changed by using the set and unset commands. Of the variables referred to by the shell a number are toggles; the shell does not care what their value is, only whether they are set or not. For instance, the verbose variable is a toggle which causes command input to be echoed. The setting of this variable results from the -v command line option.

Other operations treat variables numerically. The @ command permits numeric calculations to be performed and the result to be assigned to a variable. However, variable values are always represented as zero or more strings. For the purposes of numeric operations, the null string is considered to be 0, and the second and subsequent words of multiword values are ignored.

After the input line is aliased and parsed, and before each command is executed, variable substitution is performed, keyed by dollar sign ($) characters. This expansion can be prevented by preceding the dollar sign with a backslash (\) except within double quotation marks (") where it always occurs, and within single quotation marks (´) where it never occurs. Strings quoted by back quotation marks (`) are interpreted later (see ``Command substitution'' below) so dollar sign substitution does not occur there until later, if at all. A dollar sign is passed unchanged if followed by a blank, tab, or end-of-line.

Input and output redirections are recognized before variable expansion, and are expanded separately. Otherwise, the command name and entire argument list are expanded together. It is thus possible for the first (command) word to generate more than one word, the first of which becomes the command name, and the rest of which become arguments.

Unless enclosed in double quotation marks or given the :q modifier, the results of variable substitution may eventually be subject to command and filename substitution. Within double quotation marks ("), a variable whose value consists of multiple words expands to a portion of a single word, with the words of the variable's value separated by blanks. When the :q modifier is applied to a substitution, the variable expands to multiple words with each word separated by a blank and quoted to prevent later command or filename substitution.

The following sequences are provided for introducing variable values into the shell input. Except as noted, it is an error to reference a variable which is not set.

$name

${name}

Are replaced by the words of the value of variable name, each separated by a blank. Braces insulate name from following characters which would otherwise be part of it. Shell variables have names consisting of up to 20 letters, digits, and underscores. If name is not a shell variable, but is set in the environment, then that value is returned (but ``:'' modifiers and the other forms given below are not available in this case).

$name[selector]

${name[selector]}

May be used to select only some of the words from the value of name. The selector is subjected to $ substitution and may consist of a single number or two numbers separated by a ``-''. The first word of a variable's value is numbered 1. If the first number of a range is omitted it defaults to 1. If the last member of a range is omitted it defaults to $#name. The selector ``*'' selects all words. It is not an error for a range to be empty if the second argument is omitted or in range.

$#name

${#name}

Give the number of words in the variable. This is useful for later use in a [selector].

$0

Substitutes the name of the file from which command input is being read. An error occurs if the name is not known.

$number

${number}

Are equivalent to $argv[number].

$*

Is equivalent to $argv[*].

The following substitutions may not be modified with ``:'' modifiers.

$?name

${?name}

Substitutes the string 1 if name is set, 0 if it is not.

$?0

Substitutes 1 if the current input filename is known, 0 if it is not.

$$

Substitutes the decimal process number of the parent shell.

Command and filename substitution

Command substitution

In any case, the single final newline does not force a new word. Note that it is possible for a command substitution to yield only part of a word, even if the command outputs a complete line.

Filename substitution

The character ``~'' at the beginning of a filename is used to refer to home directories. Standing alone, it expands to the invoker's home directory contained in the variable HOME. When ``~'' is followed by a name consisting of letters, digits, and underscore characters (like_this), the shell searches for a user with that name and substitutes the user's home directory; thus ~ken might expand to /usr/ken and ~ken/chmach to /usr/ken/chmach. If the character ``~'' is followed by a character other than a letter or ``/'', or if it does not appear at the beginning of a word, it is left unchanged.

The metanotation a{b,c,d}e is shorthand for abe ace ade. Left to right order is preserved, with the results of matches being sorted separately at a low level to preserve this order. Thus ~source/s1/{oldls,ls}.c expands to /usr/source/s1/oldls.c /usr/source/s1/ls.c, whether or not these files exist, assuming that the home directory for the source is /usr/source, Similarly, ../{memo, *box} might expand to ../memo ../box ../mbox. Note that memo was not sorted with the results of matching *box. As a special case, ``{'', ``}'' and ``{}'' are passed unchanged. This construct can be nested.

The file patterns (shell regular expressions) matched by the C shell are described in regexp(M).

Spelling checker

   /usr/spool/uucp?y
   ok

Input/output

< name

Opens file name (after variable, command and filename expansion) as the standard input.

<< word

Reads the shell input up to a line which is identical to word. word is not subjected to variable, filename or command substitution, and each input line is compared to word before any substitutions are done on this input line. Unless a quoting backslash, double, or single quotation mark, or a back quotation mark appears in word, variable and command substitution is performed on the intervening lines, allowing ``\'' to quote ``$'', ``\'' and ```''. Commands which are substituted have all blanks, tabs, and newlines preserved, except for the final newline which is dropped. The resulting text is placed in an anonymous temporary file which is given to the command as standard input.

> name

>! name

>& name

>&! name

Opens the file name as the standard output. If the file does not exist, then it is created; if the file exists, it is overwritten.

If the variable noclobber is set, then an error results if the file already exists or if it is not a character special file (for example, a terminal or /dev/null). This helps prevent accidental destruction of files. In this case, the ``!'' forms can be used to suppress this check.

The forms involving ``&'' route the standard error into the specified file as well as the standard output. name is expanded in the same way as ``<'' input filenames are.

>> name

>>& name

>>! name

>>&! name

Uses file name as the standard output. This is like ``>'' but places output at the end of the file. If the variable noclobber is set, then it is an error for the file not to exist unless one of the ``!'' forms is given. Otherwise it is similar to ``>''.

The standard error may be directed through a pipe with the standard output. Simply use the form ``|&'' rather than ``|''.

Expressions

Here the precedence increases to the right, == and !=, <=, >=, <, and >, << and >>, + and -, * / and % being, in groups, at the same level. The == and != operators compare their arguments as strings, all others operate on numbers. Strings which begin with 0 are considered octal numbers. Null or missing arguments are considered 0. The results of all expressions are strings, which represent decimal numbers. Note that no two components of an expression can appear in the same word unless the word is adjacent to components of expressions that are syntactically significant to the parser (& | < > ( )). These components should be surrounded by spaces.

Also available in expressions as primitive operands are command executions enclosed in ``{'' and ``}'' and file enquiries of the form -l name where l is one of:

r

Read access

w

Write access

x

Execute access

e

Existence

o

Ownership

z

Zero size

f

Plain file

d

Directory

Command and filename expansion is applied to the specified name, then the result is tested to see if it has the specified relationship to the real user. If the file does not exist or is inaccessible then all enquiries return false, that is 0. Command executions succeed, returning true, that is 1, if the command exits with status 0, otherwise they fail, returning false, that is 0.

If more detailed status information is required then the command should be executed outside of an expression and the variable status examined.

Control flow

If the shell's input is not seekable, the shell buffers up input whenever a loop is being read and performs seeks in this internal buffer to accomplish the rereading implied by the loop. (To the extent that this allows, backward goto commands will succeed on nonseekable inputs.)

Built-in commands

alias

alias name

alias name wordlist

The first form prints all aliases. The second form prints the alias for name. The final form assigns the specified wordlist as the alias of name. wordlist is the command; filename substitution may be applied to wordlist. name is not allowed to be alias or unalias.

break

This causes execution to resume after the end of the nearest enclosing foreach or while statement. The remaining commands on the current line are executed. Multilevel breaks are thus possible by writing them all on one line.

breaksw

This causes a break from a switch, resuming after the endsw.

case label:

This is part of the switch statement discussed below.

cd [ -L | -P ] [ name ]

chdir [ -L | -P ] [ name ]

These commands change the shell's working directory to directory name. If no argument is given, the new directory is the home directory of the user. If name is not found as a subdirectory of the current directory (and does not begin with ``/'', ``./'', or ``../''), then each component of the variable cdpath is checked to see if it has a subdirectory name. Finally, if all else fails but name is a shell variable whose value begins with ``/'', then this is tried to see if it is a directory.

 

If cdspell has been set, the shell runs a spelling check as follows. If the shell is reading its commands from a terminal, and the specified directory does not exist (or some component cannot be searched), spelling correction is applied to each component of directory in a search for the ``correct'' name. The shell then asks whether or not to try and change the directory to the corrected directory name; an answer of n means ``no'', and anything else is taken as ``yes.''

The -L and -P flags are relevant to systems with symbolic links:

-L

Preserve logical pathnames so that cd -L .. moves up one component towards the root along the current logical path.

-P

Use a physical model for pathnames so that cd -L .. moves up one component towards the root by following the link to the parent of the current directory. This is the default behavior.

 

For example, if /usr/include/sys/h is a symbolic link to the directory /sys/h, then cd /usr/include/sys/h; cd -L .. would make /usr/include/sys the current directory; cd /usr/include/sys/h; cd -P .. would make /sys the current directory.

If the variable cdlogical is set, the default behavior of cd and chdir is to use logical pathnames when changing directories.

continue

This continues execution of the nearest enclosing while or foreach. The rest of the commands on the current line are executed.

default:

This labels the default case in a switch statement. The default should come after all case labels.

echo wordlist

The specified words are written to the shell's standard output. A ``\c'' causes the echo to complete without printing a newline. A ``\n'' in wordlist causes a newline to be printed. Otherwise the words are echoed, separated by spaces.

else

end

endif

endsw

See the description of the foreach, if, switch, and while statements below.

exec command

The specified command is executed in place of the current shell.

exit

exit (expr)

The shell exits either with the value of the status variable (first form) or with the value of the specified expr (second form).

foreach name (wordlist)

  ...

end

The variable name is successively set to each member of wordlist and the sequence of commands between this command and the matching end are executed. (Both foreach name (wordlist) and end must appear alone on separate lines.)

The built-in command continue may be used to continue the loop prematurely and the built-in command break to terminate it prematurely. When this command is read from the terminal, the contents of the loop are read by prompting with ``?'' until end is typed before any statements in the loop are executed.

glob wordlist

This is like echo but no ``\'' escapes are recognized and words are delimited by null characters in the output. This is useful for programs which wish to use the shell to apply filename expansion to a list of words.

goto word

Filename and command expansion is applied to the specified word to yield a string of the form label:. The shell rewinds its input as much as possible and searches for a line of the form label: possibly preceded by blanks or tabs. Execution continues after the specified line.

history

This displays the history event list.

if (expr) command

If the specified expression evaluates true, then the single command with arguments is executed. Variable substitution on command happens early, at the same time as for the rest of the if command. command must be a simple command, not a pipeline, a command list, or a parenthesized command list. Input/output redirection occurs even if expr is false, and command is not executed.

if (expr) then

  ...

else if (expr2) then

  ...

else

  ...

endif

If the specified expr is true then the commands before the first else are executed; else if expr2 is true then the commands after the second then and before the second else are executed, etc. Any number of else-if pairs are possible; only one endif is needed. The else part is likewise optional. (The words else and endif must appear at the beginning of input lines; the if (expr) then must appear alone on its input line or after an else.)

logout

This terminates a login shell. Use this if ignoreeof is set.

nice

nice +number

nice command

nice +number command

The first form sets the nice for this shell to 4. By default, commands run under C-Shell have a ``nice value'' of 0. The second form sets the nice to the given number. The final two forms run command at priority 4 and number respectively. root may specify negative niceness by using nice -number .... The command is always executed in a subshell, and the restrictions placed on commands in simple if statements apply.

nohup

nohup command

The first form can be used in shell scripts to cause hangups to be ignored for the remainder of the script. The second form causes the specified command to be run with hangups ignored. Unless the shell is running in the background, nohup has no effect. All processes running in the background with ``&'' are automatically nohuped.

onintr

onintr -

onintr label

This controls the action of the shell on interrupts. The first form restores the default action of the shell on interrupts, which is to terminate shell scripts or to return to the terminal command input level. The second form, onintr -, causes all interrupts to be ignored. The final form causes the shell to execute a goto label when an interrupt is received or a child process terminates because it was interrupted. In any case, if the shell is running in the background, interrupts are ignored whether any form of onintr is present or not.

pwd [ -L | -P ]

Prints the current working directory. The -L and -P flags are useful with symbolic links:

-L

Show the logical pathname to the directory preserving the route taken to get there.

-P

Show the physical pathname to the directory. This is the default behavior.

 

For example, if /usr/include/sys/h is a symbolic link to the directory /sys/h, then cd /usr/include/sys/h; pwd -L prints /usr/include/sys/h as the current working directory; cd/usr/include/sys/h; pwd -P prints /sys/h as the current working directory.

If the variable cdlogical is set, the default behavior of pwd is to report logical pathnames.

rehash

This causes the internal hash table of the contents of the directories in the path variable to be recomputed. This is needed if new commands are added to directories in the path while you are logged in.

repeat count command

The specified command, which is subject to the same restrictions as the command in the simple if statement above, is executed count times. I/O redirection occurs exactly once, even if count is 0.

set

set name

set name=word

set name[index]=word

set name=(wordlist)

The first form of the command shows the value of all shell variables. Variables which have other than a single word as value print as a parenthesized word list. The second form sets name to the null string. The third form sets name to the single word. The fourth form sets the indexth component of name to word; this component must already exist. The final form sets name to the list of words in wordlist. Command and filename expansion is applied in all cases. These arguments may be repeated to set multiple values in a single set command. Note however, that variable expansion happens for all arguments before any setting occurs.

setenv name value

This sets the value of the environment variable name to be value, which must be a single string. Two useful environment variables are TERM, the type of your terminal and SHELL, the shell you are using.

shift

shift variable

In the first form, the members of argv are shifted to the left, discarding argv[1]. It is an error for argv not to be set or to have less than one word as a value. The second form performs the same function on the specified variable.

source name

The shell reads commands from name. source commands may be nested, but if they are nested too deeply, the shell may run out of file descriptors. An error in a source at any level terminates all nested source commands, including the csh process from which source was called. If source is called from the login shell, it is logged out. Input during source commands is never placed on the history list.

switch (string)

case str1:

  ...

  breaksw

...

default:

  ...

  breaksw

endsw

Command and filename substitution is applied to string; each case label is then successively matched against the result. Variable expansion is also applied to the case labels, so the file metacharacters ``*'', ``?'', and ``[...]'' can be used. If none of the labels match before a default label is found, then the execution begins after the default label. Each case label and the default label must appear at the beginning of a line. The command breaksw causes execution to continue after the endsw. Otherwise control may fall through case labels and default labels, as in C. If no label matches and there is no default, execution continues after the endsw.

time

time command

With no argument, a summary of CPU time used by this shell and its children is printed. If arguments are given, the specified simple command is timed and a time summary as described under the time variable is printed. If necessary, an extra shell is created to print the time statistic when the command completes. command has the same restrictions as the simple if statement described above.

umask

umask -S

umask mask

The file creation mask is displayed if no arguments are given. Alternatively, the file creation mask is set to the value specified by mask. If mask is an octal integer, the specified bits will be set in the umask. Otherwise mask should be a symbolic mode (see chmod(C)), the new value of the file creation mask being the logical complement of the file permission bits specified.

If no umask is specified, the current file mode creation mask is printed. The default format is an octal integer. If the -S argument is given the symbolic form is printed. Common values for the mask are 002, giving all access to the group and read and execute access to others, and 022, giving read and execute access to users in the group and all other users. See also umask(C).

unalias pattern

All aliases whose names match the specified pattern are discarded. Thus, all aliases are removed by unalias *. It is not an error for nothing to be unaliased.

unhash

Use of the internal hash table to speed location of executed programs is disabled.

unset pattern

All variables whose names match the specified pattern are removed. Thus, all variables are removed by unset *; use this with care. It is not an error for nothing to be unset.

unsetenv pattern

All environment variables whose names match the specified pattern are removed.

wait

All child processes are waited for. If the shell is interactive, then an interrupt can disrupt the wait, at which time the shell prints names and process numbers of all children known to be outstanding.

while (expr)

  ...

end

While the specified expression evaluates non-zero, the commands between the while and the matching end are evaluated. break and continue may be used to terminate or continue the loop prematurely. (The while (expr) and end must appear alone on their input lines.) Prompting occurs here the first time through the loop as for the foreach statement if the input is a terminal.

@

@ name = expr

@ name[index] = expr

The first form prints the values of all the shell variables. The second form sets the specified name to the value of expr. If the expression contains <, >, & or | then at least this part of the expression must be placed within ( ). The third form assigns the value of expr to the indexth argument of name. Both name and its indexth component must already exist.

 

 

The operators *=, +=, etc. are available as in C. The space separating the name from the assignment operator is optional. Spaces are mandatory in separating components of expr which would otherwise be single words. The space between @ and name is also mandatory.

 

 

Special postfix ++ and -- operators increment and decrement name respectively, that is @ i++.

Predefined variables

The shell copies the environment variable PATH into the variable PATH, and copies the value back into the environment whenever PATH is set. Thus it is not necessary to worry about its setting other than in the file .login, since inferior csh processes will import the definition of PATH from the environment.

ARGV

Set to the arguments to the shell, it is from this variable that positional parameters are substituted, that is, $1 is replaced by argv[1], and so on. argv[0] is not defined, but $0 is.

CDPATH

This gives a list of alternate directories searched to find subdirectories in cd commands.

CHILD

This is the process number of the last command forked with ``&''. This variable is unset when this process terminates.

ECHO

This is set when the -x command line option is given. It causes each command and its arguments to be echoed just before it is executed. For non-built-in commands all expansions occur before echoing. Built-in commands are echoed before command and filename substitution, since these substitutions are then done selectively.

HISTCHARS

This can be assigned a two-character string. The first character is used as a history character in place of ``!'', the second character is used in place of the ``^'' substitution mechanism. For example, set histchars=",;" will cause the history characters to be comma and semicolon.

HISTORY

This can be given a numeric value to control the size of the history list. Any command which has been referenced in this many events will not be discarded. A history that is too large may run the shell out of memory. The last executed command is always saved on the history list.

HOME

This is the home directory of the invoker, initialized from the environment. The filename expansion of ``~'' refers to this variable.

IGNOREEOF

If this is set, the shell ignores end-of-file from input devices that are terminals. This prevents a shell from accidentally being terminated by pressing <Ctrl>d.

MAIL

These are files where the shell checks for mail. This check is executed after each command completion. The shell responds with, ``You have new mail'' if the file exists with an access time not greater than its modify time.

If the first word of the value of MAIL is numeric, it specifies a different mail checking interval: in seconds, rather than the default, which is 10 minutes.

If multiple mail files are specified, then the shell responds with ``New mail in name'', when there is mail in the file name.

NOCLOBBER

As described in the section ``Input/output'', restrictions are placed on output redirection to insure that files are not accidentally destroyed, and that >> redirections refer to existing files.

NOGLOB

If this is set, filename expansion is inhibited. This is most useful in shell scripts which are not dealing with filenames, or after a list of filenames has been obtained and further expansions are not desirable.

NONOMATCH

If this is set, it is not an error for a filename expansion not to match any existing files; rather, the primitive pattern is returned. It is still an error for the primitive pattern to be malformed, that is, echo [ still gives an error.

PATH

Each word of the PATH variable specifies a directory in which commands are to be sought for execution. A null word specifies the current directory. If there is no path variable, then only full pathnames execute. The usual search path is /bin, /usr/bin, and ., but this may vary from system to system. For root, the default search path is /etc, /bin and /usr/bin. A shell which is given neither the -c nor the -t option will normally hash the contents of the directories in the path variable after reading .cshrc, and each time the path variable is reset. If new commands are added to these directories while the shell is active, it may be necessary to give the rehash command, or the commands may not be found.

PROMPT

This is the string which is printed before reading each command from an interactive terminal input. If a ``!'' appears in the string, it will be replaced by the current event number unless a preceding ``\'' is given. The default is ``%'', or ``#'' for root.

SHELL

This is the file in which the shell resides. This is used in forking shells to interpret files which have execute bits set, but which are not executable by the system. (See the description of ``Non-built-in command execution'' below.) It is initialized to the home of the shell.

STATUS

This is the status returned by the last command. If it terminated abnormally, then 0200 is added to the status. Built-in commands which fail return exit status 1, otherwise these commands set status to 0.

TIME

This controls automatic timing of commands. If it is set, then any command which takes more than this many cpu seconds will cause a line to be sent to the screen displaying user time, system time, real time, and a utilization percentage which is the ratio of user plus system times to real time.

VERBOSE

Set by the -v command line option, this causes the words of each command to be printed after history substitution.

Non-built-in command execution

The shell concatenates each directory component of PATH with the given command name to form a pathname of a file which it then attempts to execute. This concatenation occurs if any of the following is true:

• the non-built-in command execution mechanism is turned off via unhash

• the shell is given a -c or -t argument

• the directory component of PATH does not begin with a ``/''

Parenthesized commands are always executed in a subshell. Thus:

   (cd; pwd); pwd

   cd; pwd

If the file has execute permissions but is not an executable binary to the system, then it is assumed to be a file containing shell commands and a new shell is spawned to read it.

If there is an alias for SHELL then the words of the alias are prefixed to the argument list to form the shell command. The first word of the alias should be the full pathname of the shell (for example, $shell). Note that this is a special, late occurring, case of alias substitution, and only allows words to be prefixed to the argument list without modification.

Argument list processing

-c

Commands are read from the (single) following argument which must be present. Any remaining arguments are placed in argv.

-e

The shell exits if any invoked command terminates abnormally or yields a non-zero exit status.

-f

The shell starts faster, because it neither searches for nor executes commands from the file .cshrc in the invoker's home directory.

-i

The shell is interactive and prompts for its top-level input, even if it appears not to be a terminal. Shells are interactive without this option if their input and output are terminals.

-n

Commands are parsed, but not executed. This may aid in syntactic checking of shell scripts.

-s

Command input is taken from the standard input.

-t

A single line of input is read and executed. A ``\'' may be used to escape the newline at the end of this line and continue onto another line.

-v

This causes the VERBOSE variable to be set, with the effect that command input is echoed after history substitution.

-x

This causes the ECHO variable to be set, so that commands are echoed immediately before execution.

-V

This causes the VERBOSE variable to be set even before .cshrc is executed.

-X

This causes the ECHO variable to be set even before .cshrc is executed.

After processing the flag arguments, if arguments remain but none of the -c, -i, -s, or -t options were given, the first argument is taken as the name of a file of commands to be executed. The shell opens this file, and saves its name for possible resubstitution by $0. On a typical system, most shell scripts are written for the standard shell (see sh(C)). The C shell will execute such a standard shell if the first character of the script is not a ``#'' (that is, if the script does not start with a comment). Remaining arguments initialize the variable ARGV.

Signal handling

Limitations

Commands within loops, prompted for by ``?'', are not placed in the history list.

It is not possible to use the colon (:) modifiers on the output of command substitutions.

The C shell has many built-in commands with the same name and functionality as Bourne shell commands. However, the syntax of these C shell and Bourne shell commands often differs. Two examples are the nice and echo commands. Be sure to use the correct syntax when working with these built-in C shell commands.

When a C-shell user logs in, the system reads and executes commands in /etc/cshrc before executing commands in the user's $HOME/.cshrc and $HOME/.login. You can, therefore, modify the default C shell environment for all users on the system by editing /etc/cshrc.

During intervals of heavy system load, pressing the delete key while at a C shell prompt (%) may cause the shell to exit. If csh is the login shell, the user is logged out.

csh attempts to import and export the PATH environment variable for use with regular shell scripts. This only works for simple cases, where the PATH contains no command characters.

The || and && operators are reversed in this implementation.

Words can be no longer than 512 characters. The number of arguments to a command which involves filename expansion is limited to 1/6th the number of characters allowed in an argument list, which is 5120, less the characters in the environment. The length of any argument of a command after filename expansion cannot exceed 159 characters. Also, command substitutions may substitute no more characters than are allowed in an argument list.

To detect looping, the shell restricts the number of alias substitutions on a single line to 20.

Files

~/.cshrc

read by each shell at the beginning of execution

/etc/cshrc

systemwide default .cshrc file for login C shells

~/.login

read by login shell, after .cshrc at login

~/.logout

read by login shell, at logout

/bin/sh

shell for scripts not starting with a ``#''

/tmp/sh

temporary file for <<

/dev/null

source of empty file

/etc/passwd

source of home directories for username

Open UNIX 8 compatibility notes

See also

Chapter 10, ``Configuring and working with the shells'' in the SCO OpenServer Operating System User's Guide

Standards conformance