csh(1) csh(1)
csh - shell command interpreter with a C-like syntax
csh [ -bcefinstvVxX ] [ argument ... ]
csh, the C shell, is a command interpreter with a syntax reminiscent of
the C language. It provides a number of convenient features for
interactive use that are not available with the standard (Bourne) shell,
including filename completion, command aliasing, history substitution,
job control, and a number of built-in commands. As with the standard
shell, the C shell provides variable, command and filename substitution.
Initialization and Termination [Toc] [Back]
When first started, the C shell normally performs commands from the
.cshrc file in your home directory, provided that it is readable and you
either own it or your real group ID matches its group ID. If the shell
is invoked with a name that starts with `-', as when started by login(1),
the shell runs as a login shell. In this case, before executing the
commands from the .cshrc file, the shell executes the commands from the
following files in the order specified: /etc/cshrc, /etc/.login and
/etc/csh.cshrc. These files can be used to provide system-wide settings
for all csh users. After executing commands from the .cshrc file, a
login shell executes commands from the .login file in your home
directory; the same permission checks as those for .cshrc are applied to
this file. Typically, the .login file contains commands to specify the
terminal type and environment. Please note that csh can run as a login
shell if it is invoked upon startup of a window shell such as xwsh(1G).
This is so any terminal type information that might be contained in the
.login file(s) can be made known to the window shell.
As a login shell terminates, it performs commands from the .logout file
in your home directory; the same permission checks as those for .cshrc
are applied to this file.
Interactive Operation [Toc] [Back]
After startup processing is complete, an interactive C shell begins
reading commands from the terminal, prompting with hostname<b>% (or
hostname<b># for the privileged user). The shell then repeatedly performs
the following actions: a line of command input is read and broken into
words. This sequence of words is placed on the history list and then
parsed, as described under USAGE, below. Finally, the shell executes
each command in the current line.
Noninteractive Operation [Toc] [Back]
When running noninteractively, the shell does not prompt for input from
the terminal. A noninteractive C shell can execute a command supplied as
an argument on its command line, or interpret commands from a script.
Page 1
csh(1) csh(1)
The following options are available:
-b Force a break from option processing. Subsequent command-line
arguments are not interpreted as C shell options. This allows the
passing of options to a script without confusion. The shell does
not run a set-user-ID script unless this option is present.
-c Read commands from the first filename argument (which must be
present). Remaining arguments are placed in argv, the argument-list
variable.
-e Exit if a command terminates abnormally or yields a nonzero exit
status.
-f Fast start. Read neither the .cshrc file, nor the .login file (if a
login shell) upon startup.
-i Forced interactive. Prompt for command line input, even if the
standard input does not appear to be a terminal (character-special
device).
-n Parse (interpret), but do not execute commands. This option can be
used to check C shell scripts for syntax errors.
-s Take commands from the standard input.
-t Read and execute a single command line. A `\' (backslash) can be
used to escape each newline for continuation of the command line
onto subsequent input lines.
-v Verbose. Set the verbose predefined variable; command input is
echoed after history substitution (but before other substitutions)
and before execution.
-V Set verbose before reading .cshrc.
-x Echo. Set the echo variable; echo commands after all substitutions
and just before execution.
-X Set echo before reading .cshrc.
Except with the options -c, -i, -s, or -t, the first nonoption argument
is taken to be the name of a command or script. It is passed as argument
zero, and subsequent arguments are added to the argument list for that
command or script. csh scripts should always start with the line
#! /bin/csh -f
which causes the script to be executed by /bin/csh even if invoked by a
user running a shell other than csh and inhibits processing of the .cshrc
file to prevent interference from aliases defined by the invoking user.
Page 2
csh(1) csh(1)
Filename Completion
When enabled by setting the variable filec, an interactive C shell can
complete a partially typed filename or user name. When an unambiguous
partial filename is followed by an ESC character on the terminal input
line, the shell fills in the remaining characters of a matching filename
from the working directory.
If a partial filename is followed by the EOF character (usually typed as
<Ctrl-d>), the shell lists all filenames that match. It then prompts
once again, supplying the incomplete command line typed in so far.
When the last (partial) word begins with a tilde (~), the shell attempts
completion with a user name, rather than a file in the working directory.
The terminal bell signals errors or multiple matches; this can be
inhibited by setting the variable nobeep. You can exclude files with
certain suffixes by listing those suffixes in the variable fignore. If,
however, the only possible completion includes a suffix in the list, it
is not ignored. fignore does not affect the listing of filenames by the
EOF character.
Lexical Structure [Toc] [Back]
The shell splits input lines into words at space and tab characters,
except as noted below. The characters &, |, ;, <, >, (, and ) form
separate words; if paired, the pairs form single words. These shell
metacharacters can be made part of other words, and their special meaning
can be suppressed by preceding them with a `\' (backslash). A newline
preceded by a \ is equivalent to a space character.
In addition, a string enclosed in matched pairs of single-quotes ('),
double-quotes ("), or backquotes (`), forms a partial word;
metacharacters in such a string, including any space or tab characters,
do not form separate words. Within pairs of backquote (`) or doublequote
(") characters, a newline preceded by a `\' (backslash) gives a
true newline character. Additional functions of each type of quote are
described, below, under Variable Substitution, Command Substitution, and
Filename Substitution.
When the shell's input is not a terminal, the character # introduces a
comment that continues to the end of the input line. Its special meaning
is suppressed when preceded by a \ or enclosed in matching quotes.
Command Line Parsing
A simple command is composed of a sequence of words. The first word
(that is not part of an I/O redirection) specifies the command to be
executed. A simple command, or a set of simple commands separated by |
or |& characters, forms a pipeline. With |, the standard output of the
preceding command is redirected to the standard input of the command that
follows. With |&, both the standard error and the standard output are
redirected through the pipeline.
Page 3
csh(1) csh(1)
Pipelines can be separated by semicolons (;), in which case they are
executed sequentially. Pipelines that are separated by && or || form
conditional sequences in which the execution of pipelines on the right
depends upon the success or failure, respectively, of the pipeline on the
left.
A pipeline or sequence can be enclosed within parentheses `( )' to form a
simple command that can be a component in a pipeline or sequence.
A sequence of pipelines can be executed asynchronously, or in the
background by appending an `&'; rather than waiting for the sequence to
finish before issuing a prompt, the shell displays the job number (see
Job Control, below) and associated process IDs, and prompts immediately.
History Substitution [Toc] [Back]
History substitution allows you to use words from previous command lines
in the command line you are typing. This simplifies spelling corrections
and the repetition of complicated commands or arguments. Command lines
are saved in the history list, the size of which is controlled by the
history variable. The most recent command is retained in any case. A
history substitution begins with a ! (although you can change this with
the histchars variable) and can occur anywhere on the command line;
history substitutions do not nest. The ! can be escaped with \ to
suppress its special meaning.
Input lines containing history substitutions are echoed on the terminal
after being expanded, but before any other substitutions take place or
the command gets executed.
Event Designators
An event designator is a reference to a command-line entry in the history
list.
! Start a history substitution, except when followed by a space
character, tab, newline, = or (.
!! Refer to the previous command. By itself, this substitution
repeats the previous command.
!n Refer to command line n .
!-n Refer to the current command line minus n.
!str Refer to the most recent command starting with str.
!?str[?] Refer to the most recent command containing str.
!{...} Insulate a history reference from adjacent characters (if
necessary).
Page 4
csh(1) csh(1)
Word Designators
A `:' (colon) separates the event specification from the word
designator. It can be omitted if the word designator begins with a ^, $,
*, - or %. If the word is to be selected from the previous command, the
second ! character can be omitted from the event specification. For
instance, !!:1 and !:1 both refer to the first word of the previous
command, while !!$ and !$ both refer to the last word in the previous
command. Word designators include:
# The entire command line typed so far.
0 The first input word (command).
n The n'th argument.
^ The first argument, that is, 1.
$ The last argument.
% The word matched by (the most recent) ?s search.
x<b>-y A range of words; -y abbreviates 0-y.
* All the arguments, or a null value if there is just one word in the
event.
x<b>* Abbreviates x<b>-$.
x<b>- Like x* but omitting word $.
Modifiers
After the optional word designator, you can add a sequence of one or more
of the following modifiers, each preceded by a :.
h Remove a trailing pathname component, leaving the head.
r Remove a trailing suffix of the form `.xxx', leaving the basename.
e Remove all but the suffix.
s/l<b>/r[/]
Substitute r for l.
t Remove all leading pathname components, leaving the tail.
& Repeat the previous substitution.
g Apply the change to the first occurrence of a match in each word, by
prefixing the above (for example, g&).
p Print the new command but do not execute it.
q Quote the substituted words, escaping further substitutions.
x Like q, but break into words at each space character, tab or
newline.
Unless preceded by a g, the modification is applied only to the first
string that matches l; an error results if no string matches.
The left-hand side of substitutions are not regular expressions, but
character strings. Any character can be used as the delimiter in place
of /. A backslash quotes the delimiter character. The character &, in
the right hand side, is replaced by the text from the left-hand-side.
The & can be quoted with a backslash. A null l uses the previous string
either from a l or from a contextual scan string s from !?s. You can
omit the rightmost delimiter if a newline immediately follows r; the
rightmost ? in a context scan can similarly be omitted.
Page 5
csh(1) csh(1)
Without an event specification, a history reference refers either to the
previous command, or to a previous history reference on the command line
(if any).
Quick Substitution
^l<b>^r[^] This is equivalent to the history substitution: !:s^l<b>^r[^].
Aliases [Toc] [Back]
The C shell maintains a list of aliases that you can create, display, and
modify using the alias and unalias commands. The shell checks the first
word in each command to see if it matches the name of an existing alias.
If it does, the command is reprocessed with the alias definition
replacing its name; the history substitution mechanism is made available
as though that command were the previous input line. This allows history
substitutions, escaped with a backslash in the definition, to be replaced
with actual command-line arguments when the alias is used. If no history
substitution is called for, the arguments remain unchanged.
Aliases can be nested. That is, an alias definition can contain the name
of another alias. Nested aliases are expanded before any history
substitutions is applied. This is useful in pipelines such as
alias lm 'ls -l \!* | more'
which when called, pipes the output of ls(1) through more(1).
Except for the first word, the name of the alias cannot appear in its
definition, nor in any alias referred to by its definition. Such loops
are detected, and cause an error message.
I/O Redirection
The following metacharacters indicate that the subsequent word is the
name of a file to which the command's standard input, standard output, or
standard error is redirected; this word is variable, command, and
filename expanded separately from the rest of the command.
< Redirect the standard input.
<<word Read the standard input, up to a line that is identical with
word, and place the resulting lines in a temporary file.
Unless word is escaped or quoted, variable and command
substitutions are performed on these lines. Then, invoke the
pipeline with the temporary file as its standard input. word
is not subjected to variable, filename, or command
substitution, and each line is compared to it before any
substitutions are performed by the shell.
> >! >& >&!
Redirect the standard output to a file. If the file does not
exist, it is created. If it does exist, it is overwritten; its
previous contents are lost.
Page 6
csh(1) csh(1)
When set, the variable noclobber prevents destruction of
existing files. It also prevents redirection to terminals and
/dev/null, unless one of the ! forms is used. The & forms
redirect both standard output and the standard error
(diagnostic output) to the file.
>> >>& >>! >>&!
Append the standard output. Like >, but places output at the
end of the file rather than overwriting it. If noclobber is
set, it is an error for the file not to exist, unless one of
the ! forms is used. The & forms append both the standard
error and standard output to the file.
Variable Substitution [Toc] [Back]
The C shell maintains a set of variables, each of which is composed of a
name and a value. A variable name consists of up to 20 letters and
digits, and starts with a letter (the underscore is considered a letter).
A variable's value is a space-separated list of zero or more words.
To refer to a variable's value, precede its name with a `$'. Certain
references (described below) can be used to select specific words from
the value, or to display other information about the variable. Braces
can be used to insulate the reference from other characters in an inputline
word.
Variable substitution takes place after the input line is analyzed,
aliases are resolved, and I/O redirections are applied. Exceptions to
this are variable references in I/O redirections (substituted at the time
the redirection is made), and backquoted strings (see Command
Substitution).
Variable substitution can be suppressed by preceding the $ with a \,
except within double-quotes where it always occurs. Variable
substitution is suppressed inside of single-quotes. A $ is escaped if
followed by a space character, tab or newline.
Variables can be created, displayed, or destroyed using the set and unset
commands. Some variables are maintained or used by the shell. For
instance, the argv variable contains an image of the shell's argument
list. Of the variables used by the shell, a number are toggles; the
shell does not care what their value is, only whether they are set or
not.
Numerical values can be operated on as numbers (as with the @ built-in).
With numeric operations, an empty value is considered to be zero; the
second and subsequent words of multiword values are ignored. For
instance, when the verbose variable is set to any value (including an
empty value), command input is echoed on the terminal.
Command and filename substitution is subsequently applied to the words
that result from the variable substitution, except when suppressed by
double-quotes, when noglob is set (suppressing filename substitution), or
Page 7
csh(1) csh(1)
when the reference is quoted with the :q modifier. Within double-quotes,
a reference is expanded to form (a portion of) a quoted string; multiword
values are expanded to a string with embedded space characters. When the
:q modifier is applied to the reference, it is expanded to a list of
space-separated words, each of which is quoted to prevent subsequent
command or filename substitutions.
Except as noted below, it is an error to refer to a variable that is not
set.
$var
${var<b>} These are replaced by words from the value of var, each
separated by a space character. If var is an environment
variable, its value is returned (but `:' modifiers and
the other forms given below are not available).
$var[index]
${var<b>[index<b>]} These select only the indicated words from the value of
var. Variable substitution is applied to index, which can
consist of (or result in) a either single number, two
numbers separated by a `-', or an asterisk. Words are
indexed starting from 1; a `*' selects all words. If the
first number of a range is omitted (as with $argv[-2]), it
defaults to 1. If the last number of a range is omitted
(as with $argv[1-]), it defaults to $#var (the word
count). It is not an error for a range to be empty if the
second argument is omitted (or within range).
$#name
${#name<b>} These give the number of words in the variable.
$0 This substitutes the name of the file from which command
input is being read. An error occurs if the name is not
known.
$n
${n<b>} Equivalent to $argv[n<b>].
$* Equivalent to $argv[*].
The modifiers :e, :h, :q, :r, :t and :x can be applied (see History
Substitution), as can :gh, :gt and :gr. If {} (braces) are used, then
the modifiers must appear within the braces. The current implementation
allows only one such modifier per expansion.
The following references cannot be modified with : modifiers.
$?var
${?var<b>} Substitutes the string 1 if var is set or 0 if it is not set.
Page 8
csh(1) csh(1)
$?0 Substitutes 1 if the current input filename is known, or 0 if
it is not.
$$ Substitute the process number of the (parent) shell.
$< Substitutes a line from the standard input, with no further
interpretation thereafter. It can be used to read from the
keyboard in a C shell script.
Command and Filename Substitutions
Command and filename substitutions are applied selectively to the
arguments of built-in commands. Portions of expressions that are not
evaluated are not expanded. For non-built-in commands, filename
expansion of the command name is done separately from that of the
argument list; expansion occurs in a subshell, after I/O redirection is
performed.
Command Substitution [Toc] [Back]
A command enclosed by backquotes (`...`) is performed by a subshell. Its
standard output is broken into separate words at each space character,
tab and newline; null words are discarded. This text replaces the
backquoted string on the current command line. Within double-quotes,
only newline characters force new words; space and tab characters are
preserved. However, a final newline is ignored. It is therefore
possible for a command substitution to yield a partial word.
Filename Substitution [Toc] [Back]
Unquoted words containing any of the characters *, ?, [ or {, or that
begin with ~, are expanded (also known as globbing) to an alphabetically
sorted list of filenames, as follows:
* Match any (zero or more) characters.
? Match any single character.
[ ... ] Match any single character in the enclosed list(s) or
range(s). A list is a string of characters. A range is
two characters separated by a minus-sign (-), and includes
all the characters in between in the ASCII collating
sequence (see ascii(5)).
{ str<b>, str<b>, ... }
Expand to each string (or filename-matching pattern) in
the comma-separated list. Unlike the pattern-matching
expressions above, the expansion of this construct is not
sorted. For instance, {b,a} expands to `b' `a', (not `a'
`b'). As special cases, the characters { and }, along
with the string {}, are passed undisturbed.
~[ user ] Your home directory, as indicated by the value of the
variable home, or that of user, as indicated by the
password entry for user.
Page 9
csh(1) csh(1)
Only the patterns *, ? and [...] imply pattern matching; an error
results if no filename matches a pattern that contains them. The `.'
(dot character), when it is the first character in a filename or pathname
component, must be matched explicitly. The / (slash) must also be
matched explicitly.
Expressions and Operators [Toc] [Back]
A number of C shell built-in commands accept expressions, in which the
operators are similar to those of C and have the same precedence. These
expressions typically appear in the @, exit, if, set and while commands,
and are often used to regulate the flow of control for executing
commands. Components of an expression are separated by white space.
Null or missing values are considered 0. The result of all expressions
are strings, which can represent decimal numbers.
The following C shell operators are grouped in order of precedence:
(...) grouping
~ one's complement
! logical negation
* / % multiplication, division, remainder (These are right
associative, which can lead to unexpected results.
Group combinations explicitly with parentheses.)
+ - addition, subtraction (also right associative)
<< >> bitwise shift left, bitwise shift right
< > <= >= less than, greater than, less than or equal to,
greater than or equal to
== != =~ !~ equal to, not equal to, filename-substitution pattern
match (described below), filename-substitution
pattern mismatch
& bitwise AND
^ bitwise XOR (exclusive or)
| bitwise inclusive OR
&& logical AND
|| logical OR
The operators: ==, !=, =~, and !~ compare their arguments as strings;
other operators use numbers. The operators =~ and !~ each check whether
or not a string to the left matches a filename substitution pattern on
the right. This reduces the need for switch statements when patternmatching
between strings is all that is required.
Also available are file inquiries:
-r file Return true, or 1 if the user has read access. Otherwise it
returns false, or 0.
-w file True if the user has write access.
-x file True if the user has execute permission (or search permission
on a directory).
Page 10
csh(1) csh(1)
-e file True if file exists.
-o file True if the user owns file.
-z file True if file is of zero length (empty).
-f file True if file is a plain file.
-d file True if file is a directory.
-l file True if file is a symbolic link.
-c file True if file is a character special file.
-b file True if file is a block special file.
-p file True if file is a named pipe (fifo).
-u file True if file has the set-user-ID permission bit set (see
chmod(1)).
-g file True if file has the set-group-ID permission bit set (see
chmod(1)).
-k file True if file has the sticky bit set (see chmod(1)).
-s file True if file has size strictly greater than zero.
-t file True if file is an open file descriptor for a terminal device.
If file does not exist or is inaccessible, then all inquiries return
false.
An inquiry as to the success of a command is also available:
{ command <b>} If command runs successfully, the expression evaluates to
true, 1. Otherwise it evaluates to false 0. (Note that,
conversely, command itself typically returns 0 when it
runs successfully, or some other value if it encounters a
problem. If you want to get at the status directly, use
the value of the status variable rather than this
expression).
Control Flow [Toc] [Back]
The shell contains a number of commands to regulate the flow of control
in scripts, and within limits, from the terminal. These commands operate
by forcing the shell either to reread input (to loop), or to skip input
under certain conditions (to branch).
Each occurrence of a foreach, switch, while, if...then and else built-in
must appear as the first word on its own input line.
If the shell's input is not seekable and a loop is being read, that input
is buffered. The shell performs seeks within the internal buffer to
accomplish the rereading implied by the loop. (To the extent that this
allows, backward goto commands succeed on nonseekable inputs.)
Command Execution [Toc] [Back]
If the command is a C shell built-in, the shell executes it directly.
Otherwise, the shell searches for a file by that name with execute
access. If the command-name contains a /, the shell takes it as a
pathname, and searches for it. If the command-name does not contain a /,
the shell attempts to resolve it to a pathname, searching each directory
in the path variable for the command. To speed the search, the shell
uses its hash table (see the rehash built-in) to eliminate directories
Page 11
csh(1) csh(1)
that have no applicable files. This hashing can be disabled with the -c
or -t, options, or the unhash built-in.
As a special case, if there is no / in the name of the script and there
is an alias for the word shell, the expansion of the shell alias is
prepended (without modification), to the command line. The system
attempts to execute the first word of this special (late-occurring)
alias, which should be a full pathname. Remaining words of the alias's
definition, along with the text of the input line, are treated as
arguments.
When a pathname is found that has proper execute permissions, the shell
forks a new process and passes it, along with its arguments to the kernel
(using the execve(2) system call). The kernel then attempts to overlay
the new process with the desired program. If the file is an executable
binary (in a.out(4) format) the kernel succeeds, and begins executing the
new process. If the file is a text file, and the first line begins with
#!, the next word is taken to be the pathname of a shell (or command) to
interpret that script. Subsequent words on the first line are taken as
options for that shell. The kernel invokes (overlays) the indicated
shell, using the name of the script as an argument.
If neither of the above conditions holds, the kernel cannot overlay the
file (the execve(2) call fails); the C shell then attempts to execute the
file by spawning a new shell, as follows:
o If the first character of the file is a #, a C shell is invoked.
o Otherwise, a standard (Bourne) shell is invoked.
Signal Handling [Toc] [Back]
The shell normally ignores QUIT signals. Background jobs are immune to
signals generated from the keyboard, including hangups (HUP). Other
signals have the values that the C shell inherited from its environment.
The shell's handling of interrupt and terminate signals within scripts
can be controlled by the onintr built-in. Login shells catch the TERM
signal; otherwise this signal is passed on to child processes. In no
case are interrupts allowed when a login shell is reading the .logout
file.
Job Control [Toc] [Back]
The shell associates a numbered job with each command sequence, to keep
track of those commands that are running in the background or have been
stopped with TSTP signals (typically <Ctrl-z>). When a command, or
command sequence (semicolon separated list), is started in the background
using the & metacharacter, the shell displays a line with the job number
in brackets, and a list of associated process numbers:
[1] 1234
Page 12
csh(1) csh(1)
To see the current list of jobs, use the jobs built-in command. The job
most recently stopped (or put into the background if none are stopped) is
referred to as the current job, and is indicated with a `+'. The
previous job is indicated with a `-'; when the current job is terminated
or moved to the foreground, this job takes its place (becomes the new
current job).
To manipulate jobs, refer to the bg, fg, kill, stop and % built-ins.
A reference to a job begins with a `%'. By itself, the percent-sign
refers to the current job.
% %+ %% The current job.
%- The previous job.
%j Refer to job j as in: `kill -9 %j'. j can be a job
number, or a string that uniquely specifies the command
line by which it was started; `fg %vi' might bring a
stopped vi job to the foreground, for instance.
%?string Specify the job for which the command line uniquely
contains string.
A job running in the background stops when it attempts to read from the
terminal. Background jobs can normally produce output, but this can be
suppressed using the `stty tostop' command.
Status Reporting [Toc] [Back]
While running interactively, the shell tracks the status of each job and
reports whenever a finishes or becomes blocked. It normally displays a
message to this effect as it issues a prompt, so as to avoid disturbing
the appearance of your input. When set, the notify variable indicates
that the shell is to report status changes immediately. By default, the
notify command marks the current process; after starting a background
job, type notify to mark it.
Built-In Commands [Toc] [Back]
Built-in commands are executed within the C shell. If a built-in command
occurs as any component of a pipeline except the last, it is executed in
a subshell.
: Null command. This command is interpreted, but performs
no action.
alias [ name [ def ] ]
Assign def to the alias name. def is a list of words that
can contain escaped history-substitution metasyntax. name
is not allowed to be alias or unalias. If def is omitted,
the alias name is displayed along with its current
definition. If both name and def are omitted, all aliases
are displayed.
Page 13
csh(1) csh(1)
bg [% Run the current or specified jobs in the background.
break Resume execution after the end of the nearest enclosing
foreach or while loop. The remaining commands on the
current line are executed. This allows multilevel breaks
to be written as a list of break commands, all on one
line.
breaksw Break from a switch, resuming after the endsw.
case label<b>: A label in a switch statement.
cd [ dir ]
chdir [ dir ] Change the shell's working directory to directory dir. If
no argument is given, change to the home directory of the
user. If dir is a relative pathname not found in the
current directory, check for it in those directories
listed in the cdpath variable. If dir is the name of a
shell variable whose value starts with a /, change to the
directory named by that value.
continue Continue execution of the nearest enclosing while or
foreach.
default: Labels the default case in a switch statement. The
default should come after all case labels. Any remaining
commands on the command line are first executed.
dirs [ -l ] Print the directory stack, most recent to the left; the
first directory shown is the current directory. With the
-l argument, produce an unabbreviated printout; use of the
~ notation is suppressed.
echo [ -n ] list
The words in list are written to the shell's standard
output, separated by space characters. The output is
terminated with a newline unless the -n option or the \c
escape is specified. The following C-like escape
sequences are available:
\b backspace
\c print line without newline
\f formfeed
\n newline
\r carriage return
\t tab
\\ backslash
\0n the 8-bit character whose code is the 1-, 2- or 3-
digit octal number n. Note that \n (no leading zero)
is accepted for backwards compatibility with older
IRIX cshs. This can cause unexpected results in
older scripts if the character immediately trailing
Page 14
csh(1) csh(1)
three digits is also numeric.
eval argument ...
Reads the arguments as input to the shell, and executes
the resulting command(s). This is usually used to execute
commands generated as the result of command or variable
substitution, since parsing occurs before these
substitutions. See tset(1) for an example of how to use
eval.
exec command Execute command in place of the current shell, which
terminates.
exit [ (expr<b>) ]
The shell exits, either with the value of the STATUS
variable, or with the value specified by the expression
expr.
fg % [ job ] Bring the current or specified job into the foreground.
foreach var <b>(wordlist<b>)
...
end The variable var is successively set to each member of
wordlist. The sequence of commands between this command
and the matching end is executed for each new value of
var. (Both foreach and end must appear alone on separate
lines.)
The built-in command continue can 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 loop is read up once prompting with ?
before any statements in the loop are executed.
glob wordlist Perform filename expansion on wordlist. Like echo, but no
\ escapes are recognized. Words are delimited by NULL
characters in the output.
goto label The specified label is filename and command expanded to
yield a label. The shell rewinds its input as much as
possible and searches for a line of the form label<b>:
possibly preceded by space or tab characters. Execution
continues after the indicated line. It is an error to
jump to a label that occurs between a while or for builtin,
and its corresponding end.
history [ -hr ] [ n ]
Display the history list; if n is given, display only the
n most recent events.
Page 15
csh(1) csh(1)
-r Reverse the order of printout to be most recent first
rather than oldest first.
-h Display the history list without leading numbers.
This is used to produce files suitable for sourcing
using the -h option to source.
if (expr<b>) command
If the specified expression evaluates to true, the single
command with arguments is executed. Variable substitution
on command happens early, at the same time it does for the
rest of the if command. command must be a simple command,
not a pipeline, a command list, or a parenthesized command
list. Note: I/O redirection occurs even if expr is false,
when command is not executed (this is a bug).
if (expr<b>) then
...
else if (expr2<b>) then
...
else
...
endif If expr"" is true, commands up to the first
|
