Forced 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 set-user-ID or set-group-ID scripts unless this option is present.

Executes the first argument, which must be present. Remaining arguments are placed in argv, the argument-list variable, and passed directly to csh.

Exits if a command terminates abnormally or yields a nonzero exit status.

Fast start. Reads neither the .cshrc file, nor the .login file (if a login shell) upon startup.

Forced interactive. Prompts for command line input, even if the standard input does not appear to be a terminal (character-special device).

Parses (interprets), but does not execute commands. This option can be used to check C shell scripts for syntax errors.

Takes commands from the standard input.

Reads and executes a single command line. A `\e' (backslash) can be used to escape each newline for continuation of the command line onto subsequent input lines.

Verbose. Sets the verbose predefined variable. Command input is echoed after history substitution, but before other substitutions and before execution.

Sets verbose before reading .cshrc.

Echo. Sets the echo variable. Echoes commands after all substitutions and just before execution.

Sets echo before reading .cshrc.

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.

Refer to command line n.

Refer to the current command line minus n.

Refer to the most recent command starting with str.

Refer to the most recent command containing str.

Refer to the most recent command containing str and append additional to that referenced command.

Refer to the most recent command beginning with command and append additional to that referenced command.

Repeat the previous command line replacing the string previous_word with the string replacement. This is equivalent to the history substitution:

!:s/previous_word/replacement/.

!:6s/previous_word/replacement/.

The entire command line typed so far.

The first input word (command).

The n'th argument.

The first argument, that is, 1.

The last argument.

The word matched by the ?s search.

A range of words; -y abbreviates 0-y.

All the arguments, or a null value if there is just one word in the event.

Abbreviates x-$.

Like x* but omitting word $.

Remove a trailing pathname component, leaving the head.

Remove a trailing suffix of the form `.xxx', leaving the basename.

Remove all but the suffix, leaving the Extension.

Substitute r for l.

Remove all leading pathname components, leaving the tail.

Repeat the previous substitution.

Apply the change to the first occurrence of a match in each word, by prefixing the above (for example, g&).

Print the new command but do not execute it.

Quote the substituted words,escaping further substitutions.

Like q, but break into words at each space character, tab or newline.

This is equivalent to the history substitution:

!:s/l/r/.

Redirect the standard input.

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, the pipeline is invoked 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. 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.

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).

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).

These give the number of words in the variable.

This substitutes the name of the file from which command input is being read except for setuid shell scripts. An error occurs if the name is not known.

Equivalent to $argv[n].

Equivalent to $argv[*].

Substitutes the string 1 if var is set or 0 if it is not set.

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

Substitutes 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.

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 dash (-), and includes all the characters in between in the ASCII collating sequence (see ascii(5)).

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.

Your home directory, as indicated by the value of the variable home, or that of user, as indicated by the password entry for user.

grouping

one's complement

logical negation

multiplication, division, remainder. These are right associative, which can lead to unexpected results. Combinations should be grouped 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

Return true, or 1 if the user has read access. Otherwise it returns false, or 0.

True if the user has write access.

True if the user has execute permission (or search permission on a directory).

True if filename exists.

True if the user owns filename.

True if filename is of zero length (empty).

True if filename is a plain file.

True if filename is a directory.

If command runs successfully, the expression evaluates to true, 1. Otherwise, it evaluates to false, 0. Note: 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.

If the first character of the file is a #, a C shell is invoked.

Otherwise, a Bourne shell is invoked.

The current job.

The previous job.

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.

Specify the job for which the command line uniquely contains string.

Null command. This command is interpreted, but performs no action.

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 current definition for the alias name is displayed. If both name and def are omitted, all aliases are displayed with their definitions.

Run the current or specified jobs in the background.

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.

Break from a switch, resuming after the endsw.

A label in a switch statement.

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 execution of the next iteration of the nearest enclosing while or foreach loop.

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.

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.

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 is used. csh, by default, invokes its built-in echo, if echo is called without the full pathname of a Unix command, regardless of the configuration of your PATH (see echo(1)).

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. See tset(1B) for an example of how to use eval.

Execute command in place of the current shell, which terminates.

The calling shell or shell script exits, either with the value of the status variable or with the value specified by the expression expr.

Bring the current or specified job into the foreground.

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 terminate the execution of the current iteration of the loop and the built-in command break can be used to terminate execution of the foreach command. When this command is read from the terminal, the loop is read once prompting with ? before any statements in the loop are executed.

Perform filename expansion on wordlist. Like echo, but no \e escapes are recognized. Words are delimited by NULL characters in the output.

The specified label is a filename and a command expanded to yield a label. The shell rewinds its input as much as possible and searches for a line of the form label: 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 built-in command and its corresponding end.

Print a statistics line indicating how effective the internal hash table for the path variable has been at locating commands (and avoiding execs). An exec is attempted for each component of the path where the hash function indicates a possible hit and in each component that does not begin with a `/'. These statistics only reflect the effectiveness of the path variable, not the cdpath variable.

Display the history list; if n is given, display only the n most recent events.

-r

-h

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 is true, commands up to the first else are executed. Otherwise, if expr2 is true, the commands between the else if and the second else are executed. Otherwise, commands between the else and the endif are executed. Any number of else if pairs are allowed, but only one else. Only one endif is needed, but it is required. The words else and endif must be the first nonwhite characters on a line. The if must appear alone on its input line or after an else.

List the active jobs under job control.

-l

Send the TERM (terminate) signal, by default, or the signal specified, to the specified process ID, the job indicated, or the current job. Signals are either given by number or by name. There is no default. Typing kill does not send a signal to the current job. If the signal being sent is TERM (terminate) or HUP (hangup), then the job or process is sent a CONT (continue) signal as well.

-l

Limit the consumption by the current process or any process it spawns, each not to exceed max-use on the specified resource. The string unlimited requests that the current limit, if any, be removed. If max-use is omitted, print the current limit. If resource is omitted, display all limits. Run the sysdef(1M) command to display maximum limits for certain resources in your system (although it does not report stack size). The values reported are in hexadecimal, but can be translated into decimal numbers using the bc(1) command.

-h

cputime

filesize

datasize (heapsize)

stacksize

coredumpsize

descriptors

memorysize

nh

nk

nm

mm:ss

limit coredumpsize 0M

Terminate a login shell and invoke login(1). The .logout file is not processed. If username is omitted, login prompts for the name of a user.

-p

Terminate a login shell.

Increment the process priority value for the shell or for command by n. The higher the priority value, the lower the priority of a process, and the slower it runs. When given, command is always run in a subshell, and the restrictions placed on commands in simple if commands apply. If command is omitted, nice increments the value for the current shell. If no increment is specified, nice sets the process priority value to 4. The range of process priority values is from -20 to 20. Values of n outside this range set the value to the lower, or to the higher boundary, respectively.

+n

-n

Run command with HUPs ignored. With no arguments, ignore HUPs throughout the remainder of a script. When given, command is always run in a subshell, and the restrictions placed on commands in simple if statements apply. All processes detached with & are effectively nohup'd.

Notify the user asynchronously when the status of the current job or specified jobs changes.

Control the action of the shell on interrupts. With no arguments, onintr restores the default action of the shell on interrupts. (The shell terminates shell scripts and returns to the terminal command input level). With the - argument, the shell ignores all interrupts. With a label argument, the shell executes a goto label when an interrupt is received or a child process terminates because it was interrupted.

Pop the directory stack and cd to the new top directory. The elements of the directory stack are numbered from 0 starting at the top.

+n

Push a directory onto the directory stack. With no arguments, exchange the top two elements.

+n

dir

Recompute the internal hash table of the contents of directories listed in the path variable to account for new commands added. Recompute the internal hash table of the contents of directories listed in the cdpath variable to account for new directories added.

Repeat command count times. command is subject to the same restrictions as with the one-line if statement.

With no arguments, set displays the values of all shell variables. Multiword values are displayed as a parenthesized list. With the var argument alone, set assigns an empty (null) value to the variable var. With arguments of the form var = value set assigns value to var, where value is one of:

word

(wordlist)

With no arguments, setenv displays all environment variables. With the VAR argument, setenv sets the environment variable VAR to have an empty (null) value. (By convention, environment variables are normally given upper-case names.) With both VAR and word arguments, setenv sets the environment variable NAME to the value word, which must be either a single word or a quoted string. The most commonly used environment variables, USER, TERM, and PATH, are automatically imported to and exported from the csh variables user, term, and path. There is no need to use setenv for these. In addition, the shell sets the PWD environment variable from the csh variable cwd whenever the latter changes. The environment variables LC_CTYPE, LC_MESSAGES, LC_TIME, LC_COLLATE, LC_NUMERIC, and LC_MONETARY take immediate effect when changed within the C shell. If any of the LC_* variables (LC_CTYPE, LC_MESSAGES, LC_TIME, LC_COLLATE, LC_NUMERIC, and LC_MONETARY) (see environ(5)) are not set in the environment, the operational behavior of csh for each corresponding locale category is determined by the value of the LANG environment variable. If LC_ALL is set, its contents are used to override both the LANG and the other LC_* variables. If none of the above variables is set in the environment, the "C" (U.S. style) locale determines how csh behaves.

LC_CTYPE

LC_MESSAGES

LC_NUMERIC

The components of argv, or variable, if supplied, are shifted to the left, discarding the first component. It is an error for the variable not to be set or to have a null value.

Reads commands from name. source commands can be nested, but if they are nested too deeply the shell can run out of file descriptors. An error in a sourced file at any level terminates all nested source commands.

-h

Stop the current or specified background job.

Stop the specified process, pid. (see ps(1)).

Stop the shell in its tracks, much as if it had been sent a stop signal with ^Z. This is most often used to stop shells started by su.

Each label is successively matched, against the specified string, which is first command and filename expanded. The file metacharacters *, ? and [.\|.\|.] can be used in the case labels, which are variable expanded. If none of the labels match before a "default" label is found, execution begins after the default label. Each case statement and the default statement must appear at the beginning of a line. The command breaksw continues execution after the endsw. Otherwise control falls through subsequent case and default statements as with C. If no label matches and there is no default, execution continues after the endsw.

With no argument, print a summary of time used by this C shell and its children. With an optional command, execute command and print a summary of the time it uses. As of this writing, the time built-in command does NOT compute the last 6 fields of output, rendering the output to erroneously report the value 0 for these fields.

example %time ls -R 
 9.0u 11.0s 3:32 10% 0+0k 0+0io 0pf+0w

Display the file creation mask. With value, set the file creation mask. With value given in octal, the user can turn off any bits, but cannot turn on bits to allow new permissions. Common values include 077, restricting all permissions from everyone else; 002, giving complete access to the group, and read (and directory search) access to others; or 022, giving read (and directory search) but not write permission to the group and others.

Discard aliases that match (filename substitution) pattern. All aliases are removed by `unalias *'.

Disable the internal hash tables for the path and cdpath variables.

Remove a limitation on resource. If no resource is specified, then all resource limitations are removed. See the description of the limit command for the list of resource names.

-h

Remove variables whose names match (filename substitution) pattern. All variables are removed by `unset *'; this has noticeably distasteful side effects.

Remove variable from the environment. As with unset, pattern matching is not performed.

Wait for background jobs to finish (or for an interrupt) before prompting.

While expr is true (evaluates to nonzero), repeat commands between the while and the matching end statement. break and continue can be used to terminate or continue the loop prematurely. The while and end must appear alone on their input lines. If the shell's input is a terminal, it prompts for commands with a question-mark until the end command is entered and then performs the commands in the loop.

Bring the current or indicated job to the foreground. With the ampersand, continue running job in the background.

With no arguments, display the values for all shell variables. With arguments, set the variable var, or the n'th word in the value of var, to the value that expr evaluates to. (If [n] is supplied, both var and its n'th component must already exist.) If the expression contains the characters >, <, &, or |, then at least this part of expr must be placed within parentheses. The operators *=, +=, and so forth, are available as in C. The space separating the name from the assignment operator is optional. Spaces are, however, mandatory in separating components of expr that would otherwise be single words. Special postfix operators, +\|+ and -\|-, increment or decrement name, respectively.

Argument list. Contains the list of command line arguments supplied to the current invocation of the shell. This variable determines the value of the positional parameters $1, $2, and so on.

Contains a list of directories to be searched by the cd, chdir, and popd commands, if the directory argument each accepts is not a subdirectory of the current directory.

The full pathname of the current directory.

Echo commands (after substitutions) just before execution.

A list of filename suffixes to ignore when attempting filename completion. Typically the single word `.o'.

Enable filename completion, in which case the Control-d character EOT and the ESC character have special significance when typed in at the end of a terminal input line:

EOT

ESC

If set, pathnames in the directory stack are resolved to contain no symbolic-link components.

A two-character string. The first character replaces ! as the history-substitution character. The second replaces the carat (^) for quick substitutions.

The number of lines saved in the history list. A very large number can use up all of the C shell's memory. If not set, the C shell saves only the most recent command.

The user's home directory. The filename expansion of ~ refers to the value of this variable.

If set, the shell ignores EOF from terminals. This protects against accidentally killing a C shell by typing a Control-d.

A list of files where the C shell checks for mail. If the first word of the value is a number, it specifies a mail checking interval in seconds (default 5 minutes).

Suppress the bell during command completion when asking the C shell to extend an ambiguous filename.

Restrict output redirection so that existing files are not destroyed by accident. > redirections can only be made to new files. >> redirections can only be made to existing files.

Inhibit filename substitution. This is most useful in shell scripts once filenames (if any) are obtained and no further expansion is desired.

Return the filename substitution pattern, rather than an error, if the pattern is not matched. Malformed patterns still result in errors.

If set, the shell notifies you immediately as jobs are completed, rather than waiting until just before issuing a prompt.

The list of directories in which to search for commands. path is initialized from the environment variable PATH, which the C shell updates whenever path changes. A null word ('') specifies the current directory. The default is typically (/usr/bin .). One can override this initial search path upon csh start-up by setting it in .cshrc or .login (for login shells only). If path becomes unset, only full pathnames execute. An interactive C shell normally hashes the contents of the directories listed after reading .cshrc, and whenever path is reset. If new commands are added, use the rehash command to update the table.

The string an interactive C shell prompts with. Noninteractive shells leave the prompt variable unset. Aliases and other commands in the .cshrc file that are only useful interactively, can be placed after the following test: `if ($?prompt == 0) exit', to reduce startup time for noninteractive shells. A ! in the prompt string is replaced by the current event number. The default prompt is hostname% for mere mortals, or hostname# for the privileged user. The setting of $prompt has three meanings:

$prompt not set

$prompt set but == ""

$prompt set and != ""

The number of lines from the history list that are saved in ~/.history when the user logs out. Large values for savehist slow down the C shell during startup.

The file in which the C shell resides. This is used in forking shells to interpret files that have execute bits set, but that are not executable by the system.

The status returned by the most recent command. If that command terminated abnormally, 0200 is added to the status. Built-in commands that fail return exit status 1; all other built-in commands set status to 0.

Control automatic timing of commands. Can be supplied with one or two values. The first is the reporting threshold in CPU seconds. The second is a string of tags and text indicating which resources to report on. A tag is a percent sign (%) followed by a single upper-case letter (unrecognized tags print as text):

%D

%E

%F

%I

%K

%M

%O

%P

%S

%U

%W

%X

Display each command after history substitution takes place.

Read at beginning of execution by each shell.

Read by login shells after .cshrc at login.

Read by login shells at logout.

Saved history for use at next login.

The Bourne shell, for shell scripts not starting with a `#'.

Temporary file for `<<'.

Source of home directories for `~name'.

You attempted to exit the C shell with stopped jobs under job control. An immediate second attempt to exit succeeds, terminating the stopped jobs.