Content-type: text/html
csh - C shell command interpreter
csh [-bcefinstvVxX] [argument...]
The
csh
command invokes the C shell and interprets
C shell commands.
Forces a break from option processing, causing any further shell arguments to be treated as nonoption arguments. This can be used to pass options to a shell script without confusion or possible subterfuge. The shell cannot run a set-user-ID script without this option. Reads commands from the following single argument, which must be present. Any remaining arguments are placed in argv. Causes the shell to exit if any invoked command terminates abnormally or yields a nonzero exit status. Causes the shell to start faster, because it neither searches for nor executes the .cshrc file in the invoker's home directory. Causes the shell to be interactive, even if the input does not come from a terminal. Shells are always interactive when invoked from a terminal. Parses commands, but does not execute them. This aids in syntactic checking of shell scripts. Takes command input from the standard input. Reads and executes a single line of input. You can use a \ (backslash) to escape the newline character at the end of the current line to continue onto another line. Sets the verbose shell variable, with the effect that command input is echoed to the standard output after history substitution. Sets the verbose shell variable, even before .cshrc is executed. Sets the echo shell variable, so that commands are echoed to the standard error after all substitutions and immediately before execution. Sets the echo shell variable, even before .cshrc is executed.
After processing of option arguments, if arguments remain but none of
the
-c,
-i,
-s, or
-t
options was given, the first argument is taken as the name of a
file of commands to be executed (that is, a shell script). The shell opens
this file, and saves its name for possible resubstitution by
$0.
If the first characters of the shell script are
#!shell_pathname
or
#csh,
csh
runs the specified shell to process the script. Otherwise,
csh
runs. Remaining parameters initialize the
argv
variable.
The C shell is an interactive command interpreter and a command programming language that uses a syntax similar to the C programming language. The shell carries out commands either from a file (called a shell script or procedure) or interactively from a terminal keyboard.
When you run csh, it begins by executing commands from the file .cshrc in your home directory, if it exists. If the shell is invoked with a name that starts with -, as when started by login, the shell runs as a login shell. If csh runs as a login shell, it executes commands from the system-wide login file /etc/csh.login, if that file exists, and then commands from your $home/.cshrc file and your $home/.login file, in that order. (If argument zero ($0) to the shell is a - (dash), then the shell is a login shell.) Your system administrator can create /etc/csh.login to provide a standardized environment for all users, but you can include commands in $home/.cshrc or $home/.login to override settings and assignments made by /etc/csh.login.
At log in, the $home shell variable and the $HOME environment variable both refer to your home directory. If you subsequently change $home to some other value, you will encounter problems because the shell will not be able to find files it uses, such as .cshrc and .bindings.
In the normal case, the shell begins reading commands from the terminal, prompting with % (percent sign) or # (number sign) for the superuser. Processing of arguments and the use of the shell to process files containing command scripts is described later.
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 command history list and then parsed. Each command in the current line is executed.
When a login shell terminates, it executes commands from the file
.logout
in your home directory.
Job control and status reporting
File name completion
History substitution
Command aliasing
Variable substitution
Command substitution
File name substitution
Input/output redirection and control flow
Built-in commands
A simple command is a sequence of words separated by spaces or tabs. The shell splits input lines into words at spaces and tabs with the following exceptions: The characters &, |, ;, <, >, (, ), and # form separate words. If doubled in &&, ||, <<, or >>, these pairs form single words. Preceding parser metacharacters with a \ (backslash) prevents the shell from interpreting them as special characters. A newline preceded by a \ (backslash) is equivalent to a space. Strings enclosed in " " (double quotes), ` ` (grave accents), or ' ' (single quotes) form parts of a word; metacharacters in these strings, including spaces and tabs, do not form separate words. For more information, see the section Quoting with Single and Double Quotes. Within pairs of ' or " characters, you can include the newline character by preceding it with a \ (backslash). When the shell is not reading input from a terminal, it treats any word that begins with a # (number sign) character as a comment and ignores that word and all characters following up to the next newline character. The # character loses its special meaning when it is quoted (preceded) by a \ (backslash) or when the string is enclosed in quotes using `, ', or ".
A simple command is a sequence of words, the first of which (numbered 0) specifies the command to be executed. Any remaining words, with a few exceptions, are passed to that command. If the command specifies an executable file that is a compiled program, the shell immediately runs that program. If the file is marked executable but is not a compiled program, the shell assumes that it is a shell script. In this case, it starts another shell to read the file and execute the commands included in it. (See the section Nonbuilt-In Command Execution for information about using the $shell variable to determine which shell is executed.)
A pipeline is a sequence of one or more commands separated by either the | (vertical bar) or |& (vertical bar and ampersand) characters. 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. Note that you cannot pipe to a built-in command and an attempt to do so generates an error message. A list is a sequence of pipelines separated by a ; (semicolon), & (ampersand), && (two ampersands), or || (two vertical bars) and optionally ended by a ; (semicolon) or an & (ampersand). These separators and terminators have the following effects: Causes sequential execution of the preceding pipeline (the shell waits for the pipeline to finish). Causes asynchronous execution of the preceding pipeline (the shell does not wait for the pipeline to finish). Causes the list following it to be executed only if the preceding pipeline returns a 0 (zero) exit value. Causes the list following it to be executed only if the preceding pipeline returns a nonzero exit value.
The
;
(semicolon) and
&
(ampersand)
separators have equal precedence, as do
&&
and
||. The single-character separators have lower precedence than
the double-character separators. A newline character without quotes following
a pipeline functions the same as a
;
(semicolon). A pipeline
or sequence can be enclosed in
()
(parentheses) to form
a simple command.
The shell associates a job with each pipeline. It keeps a table of current jobs and assigns them small integer numbers. When you start a job asynchronously by terminating the command with &, the shell displays a line that looks like this: [1] 1234
This line indicates that the job number is 1 and that the job is composed of one process with the process ID of 1234. Use the built-in jobs command to see the table of current jobs.
If you are running a job and want to do something else, you can enter the Suspend key sequence (normally <Ctrl-z>) which sends a stop signal to the current job. The shell then normally indicates that the job has been stopped and it prints another prompt. You can then manipulate the state of this job, putting it in the background with the bg command, or run some other commands and then eventually bring the job back into the foreground with the foreground command fg. The job suspension takes effect immediately, and is similar to the Interrupt key sequence in that pending output and unread input are discarded. A special key sequence, <Ctrl-y>, does not generate a stop signal until a program attempts to read it. (See the read() system call for more information.) This key sequence can usefully be typed ahead when you have prepared some commands for a job that you want to stop after it has read them.
A job being run in the background stops if it tries to read from the terminal. Background jobs are normally allowed to produce output, but this can be disabled by entering the stty tostop command. If you set this terminal option, background jobs stop when they try to produce output like they do when they try to read input.
There are several ways to refer to jobs in the shell. Use the % (percent sign) with the fg and bg built-in commands to control the job. This name can be either the job number or a prefix of the string that started the job, if this name is unique. (% can be used to refer to both background and foreground jobs.)
For example, if a make process is running as job number 1, you can refer to it as %1. You can also refer to it as %make, if there is only one job with a name that begins with the string make. You can also use the following characters to specify a job whose name contains string, if there is only one such job: %?string
Just naming a job brings it to the foreground, so %1 is a synonym for fg %1, bringing job 1 back into the foreground. Similarly, entering %1 & resumes job 1 in the background. Thus, %ex normally restarts a stopped ex job if there was only one stopped job whose name began with the string ex.
The shell maintains a notion of the current and previous jobs. In output
produced by the built-in command
jobs, the current job
is marked with a
+
(plus sign) and the previous job with
a
-
(dash). The abbreviation
%+
refers to the current job and
%-
refers to the previous
job. For close analogy with the syntax of the history mechanism (described
later),
%%
is also a synonym for the current job.
The shell tracks the state of each job and reports whenever a job finishes or becomes blocked. The shell prints the status information just before it prints the prompt to avoid disturbing the appearance of the terminal screen. If, however, you set the notify shell variable, the shell notifies you immediately of changes of status in background jobs. There is also a notify shell command that marks a single process so that its status changes are immediately reported. By default notify marks the current process. Simply enter notify after starting a background job to mark the job.
When you try to leave the shell while jobs are stopped, you are warned
that you have stopped jobs. You can use the built-in
jobs
command to see what they are. If you then immediately exit the shell, or
use
jobs
and then exit, the shell does not warn you a second
time, and the suspended jobs are terminated.
The file name completion feature is enabled by setting the shell variable filec. The csh interactively completes file names and user names from unique prefixes when they are input from the terminal followed by the escape character (the <ESC> key or <Ctrl-[>)). For example, assume the current directory looks like this:
DSC.OLD bench chaos cmd dev mail xmpl.c xmpl.out DSC.NEW bin class cmtest lib mbox xmpl.o
The input is as follows: % vi ch<ESC>
The csh completes the prefix ch to the only matching file name chaos: vi chaos
However, given the following command line: vi D<ESC>
csh only expands the input as follows: vi DSC.
The csh sounds the terminal bell to indicate that the expansion is incomplete, because two file names match the prefix D.
If a partial file name is followed by the End-of-File character (shown here as <Ctrl-d>), then instead of completing the name, csh lists all file names matching the prefix. For example, the following input causes all files beginning with D to be listed: vi D<Ctrl-d>
DSC.NEW DSC.OLD
The input line is then echoed again for you to complete.
The same system of <ESC> and <EOF> can also be used to expand partial user names, if the word to be completed (or listed) begins with ~ (tilde). For example, entering the following command line: cd ~ro<ESC>
can produce the following expansion: cd ~root
The use of the terminal bell to signal errors or multiple matches can be inhibited by setting the variable nobeep.
Normally, all files in the particular directory are candidates for name completion. Files with certain suffixes can be excluded from consideration by setting the variable fignore to the list of suffixes to be ignored. Thus, if fignore is set by the following command: % set fignore = (.o .out)
typing % vi x<ESC>
results in the completion to % vi xmpl.c
ignoring the files
xmpl.o
and
xmpl.out. However, if the only completion possible requires not ignoring
these suffixes, then they are not ignored. In addition,
fignore
does not affect the listing of file names by
<Ctrl-d>. All files are listed regardless of their suffixes.
History substitution places words from previous command input as portions of new commands, making it easy to repeat commands, repeat arguments of a previous command in the current command, or fix spelling mistakes in the previous command with little typing. History substitutions begin with the ! (exclamation point) character and can begin anywhere on the command line, provided they do not nest (in other words, a history substitution cannot contain another history substitution). You can precede the ! with a \ (backslash) to prevent the exclamation point's special meaning. In addition, if you place an ! (exclamation point) before a space, tab, newline, = (equal sign), or ( (left parenthesis), the exclamation point is passed to the parser unchanged. (History substitutions also occur when you begin an input line with a ^ (circumflex). This special abbreviation is described later.) The shell echoes any input line containing history substitutions before it executes that command line.
Commands input from the terminal that consist of one or more words are saved on the history list. The history substitutions reintroduce sequences of words from these saved commands into the input stream.
The
history
shell variable controls the size of the
history list. You must set the
history
shell variable
either in the
.cshrc
file or on the command line with
the built-in
set
command. The previous command is always
retained, however, regardless of the value of
history.
Commands in the history list are numbered sequentially, starting from 1.
The built-in
history
command produces output of the type:
9 write michael
10 ex write.c
11 cat oldwrite.c
12 diff *write.c
The command strings are shown with their event numbers. It is not usually necessary to use event numbers to refer to events, but you can have the current event number displayed as part of your system prompt by placing an ! (exclamation point) in the prompt string assigned to the prompt variable.
A full history reference contains an event specification, a word designator, and one or more modifiers in the following general format:
event[:]word:modifier[:modifier]...
Note that only one word can be modified. A string that contains spaces is not allowed.
In the previous sample of history command output, the current event number is 13. Using this example, the following refer to previous events: Refers to event number 10. Refers to event number 11 (the current event minus 2). Refers to a command word beginning with d (in this case, event number 12). Refers to a command word that contains the string mic (in this case, event number 9).
These forms, without further modification, simply reintroduce the words of the specified events, each separated by a single space. As a special case, !! refers to the previous command. (The !! command alone on an input line reruns the previous command.)
To select words from an event, follow the event specification by a : (colon) and one of the following word designators. The words of an input line are numbered sequentially, starting from 0 (zero), with the first (usually command) word being 0 (zero), the second word (first argument) being 1, and so on. The basic word designators are as follows: First word (command). The nth argument, where n > 0, for example, !!:3 recalls the third word of the previous command and !:2 recalls to the second word of the current command. !#:n is the same as !:n and recalls the nth word of the current command. First word (word 1). Last word. Word matched by (the immediately preceding) ?string? history search. Range of words from x through y. Words 0-y. The second through the last words, or nothing if only one word in event. Words x- $ Like x*, but omits the last word ($).
You can omit the : (colon) separating the event specification from the word designator if the word designator begins with a ^, $, *, -, or %. You can also place a sequence of modifiers, each preceded by a : (colon), after the optional word designator. The following modifiers are defined: Repeats the previous substitution. Removes all but the trailing extension .xxx. Applies the change globally, prefixing another modifier, for example g&. Removes a trailing path name extension, leaving the head. Prints the new command, but does not execute it. Quotes the substituted words, thus preventing further substitutions. Removes a trailing .xxx component, leaving the root name. Substitutes r for l. It is an error for no word to be applicable. Removes all leading path name components, leaving the tail. Like q, but breaks into words at space, tab or newline.
Unless the modifier is preceded by a g, the change is applied only to the first modifiable word.
The l (left) side of a substitution is not a pattern in the sense of a string recognized by an editor; rather, it is a word, a single unit without spaces. Normally, a / (slash) delimits the word (l) and its replacement (r). However, you can use any character as the delimiter. Thus, in the following example the = character becomes the delimiter, allowing you to include the / in your word: s=/usr/myfile=/usr/yourfile=
If you include an & (ampersand) in the replacement (r), it is replaced by the text from the left-hand side (l). A null l side is replaced by either the last l string or by the last string used in the contextual scan !?string?. You can omit the trailing delimiter (/) if a newline character follows immediately.
A history reference can be given without an event specification. For example, !$ refers to the last argument of the previous command. If a history reference without an event specification is not the first history reference on the line, it refers to the previous history reference on the line and not to a previous event. For example, in !?foo?^ !$, !?foo?^ gives the first argument of the command matching ?foo?, and the !$ gives the last argument of that same command, not the last argument of the previous command (as it would if it were on a line by itself).
A special abbreviation of a history reference occurs when the first
nonspace character of an input line is a
^
(circumflex).
This is equivalent to
!:s^, providing a convenient shorthand
for substitutions on the text of the previous line. Thus,
^lb^lib
corrects the spelling of
lib
in the previous
command. Finally, a history substitution can be enclosed in
{
}
(braces) to insulate it from the characters that follow. Thus,
after
ls -ld ~paul
you might specify
!{l}a
to do
ls -ld ~paula, or
!la
to rerun a command starting with
la.
If you are using a video display terminal or a workstation terminal emulator, csh allows you to recall and edit commands as if you were using an editor; this capability is in addition to the history mechanism. This version of the C shell provides intra-command line editing that includes features such as a kill buffer, multiline named keyboard macros which can be automatically saved and restored, convenient access to the history list, and user settable key bindings. A summary of the currently available functions is provided below. In most cases, the functionality is apparent from the names of the routines in the list.
The shell's editing mode is determined by the value of the shell editmode variable which users should set to emacs or vi in their .cshrc files. If editmode is not set, then the shell will run in ``dumb'' mode. It is possible to set the mode after the shell starts up; so if you find yourself in ``dumb'' mode, you can alter the situation without having to log out and log in again. Setting the editmode variable has two important side effects: (1) it causes the key bindings to be reevaluated, and (2) it sets the EDITMODE environment variable. The latter has no effect within the shell; so users should not set the environment variable directly in hopes of altering the editing mode.
Terminal control capabilities are extracted from the user's termcap file (usually /etc/termcap), using the value of the shell variable term, not the environment variable TERM, as the terminal type. If term is undefined, unknown, or if the associated termcap definition is inadequate, a warning will be displayed and most, or all, of the editing features of the shell will be disabled. It is the user's responsibility to make sure that term is set to an appropriate value before the shell editor is initialized. Usually this should be done in the .login file. If editing is disabled because term is not properly set when the shell starts up, simply setting term to the proper value will normally cause the shell editor to be reenabled. NB: Setting the shell variable term causes the environment variable TERM to be set to the same value. For information on controlling the bell, see the ERRORS section.
There is a bind-to-key command in this shell, which allows the functions listed in the table on bindings below, and also user defined keyboard macros, to be bound to keys. The form of the command is bind-to-key function key ...
where function is one of the function names from the list or else the single character name of a keyboard macro and where key is a quoted string designating a key sequence. Control characters in the key designation should not be entered literally, but should be indicated by the prefix "\^", e.g. "\^X". Similarly, escape is indicated by "\e". A literal backslash is "\\". Escape and control-X are the only legitimate ``prefix'' characters. For vi mode, bindings prefixed with control-X are for insert mode. Otherwise, the bindings are in effect only in command mode. The following mnemonics should be used:
\^? | delete (rubout) |
\^c | control character |
\n | line feed (new line) |
\b | back space |
\t | horizontal tab |
\v | vertical tab |
\f | form feed |
\r | carriage return |
\e | escape |
\nnn | character code in octal |
Since the shell converts returns to newlines it is probably unwise to alter which would be accomplished using the following command: bind-to-key KillRegion "\^U"
During editor initialization the shell will read a file named .bindings in the user's home directory. If you regularly want certain non-default key bindings to be effective, put the appropriate bind-to-key commands in your ~/.bindings file.
NB: Do not place the bind-to-key commands in your ~/.cshrc or ~/.login file; they must be in the ~/.bindings file.
Invocation of the history mechanism with "!" either causes the matched command to be inserted on the command line for editing before execution or immediately executes the command. This is controlled by the shell variable edithist, which is automatically set, when the shell variable editmode is set, thereby allowing editing of previous commands invoked by the history mechanism. This feature may be turned off with the command "unset edithist", which may be placed in the user's .cshrc file.
The following table shows the current functions and default key bindings:
Emacs | Function Name | Remark |
^B | Backspace | |
ESC-b | BackwardWord | |
^A | BeginningOfLine | |
^L | ClearScreen | |
DefaultBinding | ||
ESC-n | DefineNamedMacro | name macro |
^D | DeleteCurrentChar | |
^H | DeletePreviousChar | |
ESC-d | DeleteWord | after cursor |
EndOfFile | exit shell | |
^E | EndOfLine | |
EraseLine | kills whole line | |
ESC-h | EraseWord | before cursor |
ExecuteMacro | ||
ESC-e | ExecuteNamedMacro | |
ESC-x | ExecuteNamedMacro | |
^X-e | ExecuteUnNamedMacro | |
ESC-ESC | FilenameExpansion | |
ESC-l | FilenameList | |
^F | ForwardChar | |
ESC-f | ForwardWord | |
GnuTransposeChars | like gnu-emacs | |
IncrementalSearchForward | ||
IncrementalSearchReverse | ||
InsertChar | self insert | |
^V | InsertLiteralChar | |
^W | KillRegion | to kill buffer |
^K | KillToEOL | to kill buffer |
^X^R | LoadMacroFile | |
^N | NextHistEntry | wraps around |
^P | PreviousHistEntry | wraps around |
^R | Redisplay | redraws line |
^U | Repetition | greater than 0 |
^M,^J | Return | |
^X^S | SaveMacroFile | |
^@ | SetMark | default mark at BOL |
SearchReverse | look for next char | |
SearchForward | look for next char | |
^Q | StartFlow | (see FLOW CONTROL) |
^X-( | StartRemembering | begin a macro |
^S | StopFlow | (see FLOW CONTROL) |
^X-) | StopRemembering | end a macro |
^I | Tab | inserts 8 spaces |
^T | TransposeChars | before cursor |
WipeLine |
kill line without saving
| |
^Y | YankKillBuffer | no kill ring |
Vi | Function Name | Remark |
A | AppendToEOL |
can't use with
bind-to-key
|
^H | BackSpace | |
h | BackSpace | |
B | BackwardWord | |
b | BackwardWord | |
0 | BeginningOfLine | |
^ | BeginningOfLine | |
s | ChangeChar |
can't use with
bind-to-key
|
c | ChangeFollowingObject |
can't use with
bind-to-key
|
C | ChangeToEOL |
can't use with
bind-to-key
|
S | ChangeWholeLine |
can't use with
bind-to-key
|
x | DeleteCurrentChar | |
d | DeleteFollowingObject |
can't use with
bind-to-key
|
X | DeletePreviousChar |
can't use with
bind-to-key
|
$ | EndOfLine | |
ESC | FilenameExpansion | |
^D | FilenameListOrEof | |
l | ForwardChar | |
SPACE | ForwardChar | |
w | ForwardWord | |
W | ForwardWord | |
e | ForwardWord | |
I | InsertAtBOL |
can't use with
bind-to-key
|
D | KillToEOL | |
@ | ExecuteNamedMacro | |
+ | NextHistEntry | |
j | NextHistEntry | |
^N | NextHistEntry | |
- | PreviousHistEntry | |
k | PreviousHistEntry | |
^P | PreviousHistEntry | |
^L | Redisplay | |
^R | Redisplay | |
z | Redisplay | |
1-9 | Repetition | |
r | ReplaceChar |
can't use with
bind-to-key
|
LINEFEED | Return | |
RETURN | Return | |
/ | IncrementalSearchForward | |
? | IncrementalSearchReverse | |
f | SearchForward | |
F | SearchReverse | |
m | SetMark | |
a | EnterViAppend |
can't use with
bind-to-key
|
i | EnterViInsert |
can't use with
bind-to-key
|
p | ViYankKillBuffer |
can't use with
bind-to-key
|
P | ViYankKillBuffer |
can't use with
bind-to-key
|
Vi insert mode | ||
^H | DeletePreviousChar | |
EraseChar | DeletePreviousChar | |
^W | EraseWord | |
ESC | ExitViInsert |
can't use with
bind-to-key
|
^D | FilenameListOrEof | |
^Q | InsertLiteralChar | |
^V | InsertLiteralChar | |
^U | KillRegion | |
^N | NextHistEntry | |
^P | PreviousHistEntry | |
^L | Redisplay | |
^R | Redisplay | |
LINEFEED | Return | |
RETURN | Return | |
TAB | Tab |
Users may change the bindings of functions to keys by means of the shell bind-to-key command. These commands may be stored in a file named .bindings in the user's home directory and will then be read by the shell when the editor is initialized.
Flow control is handled by the terminal driver, not by the shell. The terminal driver normally interprets ^S and ^Q as a signal to respectively stop and restart output to the terminal. By default, the shell does not override these ``bindings``, but the user may override them by rebinding ^S or ^Q to functions other than StopFlow and StartFlow.
The functions StopFlow and StartFlow can only be usefully bound to the keys that the terminal driver interprets as performing the corresponding flow control functions. In other words, you cannot simply bind these functions to other keys in order to have them perform the flow control operations normally provided by ^S and ^Q.
Keyboard macros can be used to simplify repetitive operations and reduce typing lengthy commands. For example, the following lines illustrate how to create a macro to startup Emacs and have it run the shell inside a buffer:
% ^X(emacs -eshell % ^X)
Notice that this is a multiline macro, since it contains an embedded newline. The user can give this macro a single character name, e.g. ``e'', as follows:
% \ene (escape-n-e).
The macro may then be executed by typing ``\exe''. It can also be bound to a key using the bind-to-key command. Macros can be saved in files and can be reloaded automatically when the shell starts up. To create a new unnamed macro, use the StartRemembering function which is bound by default to ^X(. Subsequent keystrokes, until the StopRemembering, ^X ), function is executed, are remembered as an ``unnamed'' keyboard macro. It can contain at most 1024 characters. You are not allowed to begin creating another macro during macro creation, but it is okay to execute other macros, provided loops are not created. The unnamed macro can be executed using the ExecuteUnNamedMacro function, bound to ^Xe. There is only one unnamed macro. Users can have up to 128 named macros. To define such a macro, first create an unnamed macro as above and then give it a name by executing the DefineNamedMacro function, bound to \en (escape-n). The function takes a single character argument which will be the name of the macro. Any previous macro with that same name will be destroyed. To execute a named macro simply use the ExecuteNamedMacro function, bound to \ex, and give it the name of the macro to be executed. Named macros can also be bound to keys using the built-in C shell command bind-to-key. Named keyboard macros can be saved in files and loaded from files. To save the named macros in a file simply type the file name on the command line (by itself) and then execute the SaveMacroFile function bound to ^X^S. To read a file of previously saved macros type the file name on the command line and execute the LoadMacroFile function bound to ^X^R. Success in each case is indicated by the erasure of the file name. It is okay to store macros in several different macro files. NB: It is not advisable to try to edit saved macros! If the shell variable macrofiles is assigned (in the user's .cshrc file) the names of one or more files of saved keyboard macros, then those macro files will be automatically loaded when the shell starts up. Similarly, the variable savemacros can be assigned the name of a (single) file in which all named macros will be saved when the user logs out.
NB: The names of the incremental search functions have changed since earlier releases of this shell.
Four search functions are available to the user, but are not bound (by default) to keys. If you want to use them, use the C shell bind-to-key command to bind them to keys. When the user executes this function he is placed in a read/search loop in which the string to be found is built up character by character. As each new character is added to the search string the cursor is placed at the end of the first match on the command line following the position of the cursor when the function was executed. You can reexecute the search function while in the loop to cause the cursor to move to subsequent matches. Type ESC to exit the loop. This function is similar to IncrementalSearchForward except that the cursor is placed at the beginning of the first match on the command line preceding the position of the cursor when the function was executed. This function grabs the next character you type and searches for that character from the position of the cursor to the end of the command line, leaving the cursor following the first instance of the character if one is found. This function is like SearchForward except that it searches from where the cursor is to the beginning of the command line.
If the shell variable breakchars is assigned a string, then the characters in that string are used to determine word boundaries. The default break characters are " ", ",", ^I, /, \, (, ), [, ], {, }, ., ;, >, <, !, ^, &, and |. The user defined break characters are used instead of, not in addition to, the default list.
The display update functions take no advantage of the capabilities of smart terminals. This will be fixed in the future.
The command line cannot exceed 1024 characters if characters are being inserted in the middle of the line; it can be longer if characters are being inserted at the end, but once the 1K boundary is passed the previous characters can no longer be edited or redisplayed.
The interactive input routine performs some initialization the first time it is called. As a result some things are not interactively alterable. It is also not possible for the user to turn off echoing of regular characters or to take the terminal out of CBREAK mode by means of the stty command, for example, and have it affect the function of the shell.
Error conditions within the editor functions are usually indicated by
an audible bell. If you prefer a visual signal and your terminal has a visible
bell capability, then you should set the variable
visiblebell
in your
.cshrc
file. If you want an audible bell also,
then set both
visiblebell
and
audiblebell.
If you don't want to be told about your mistakes, you can set the
nobell
variable.
Enclose strings in single and double quotes to prevent all or some of
the substitutions that remain. Enclosing strings in
' '
(single quotes) prevents any further interpretation except history substitution.
Enclosing strings in
" "
(double quotes) allows further
variable and command expansion. In both cases, the text that results becomes
(all or part of) a single word. Only in one special case does a string quoted
by
" "
yield parts of more than one word; strings quoted
by
' '
never do (see
Command Substitution).
The shell maintains a list of aliases that the alias and unalias built-in commands can establish, display, and modify. After the shell scans a command line, it divides the line into distinct commands and checks the first word of each command, left to right, to see if it has an alias. If an alias exists, the text defined as the alias for that command is reread with the history mechanism, as if the alias were the previous input line. The words that result replace the command and argument list. If no reference is made to the history list, the argument list is left unchanged.
Thus, if the alias for ls is ls -l, the shell replaces the command ls /usr with ls -l /usr. The argument list is left unchanged because there is no reference to the history list in the command with an alias. Similarly, if the alias for lookup is grep !^ /etc/passwd, then lookup bill maps to grep bill /etc/passwd.
Here !^ refers to the history list and the shell replaces it with the first argument in the input line, in this case bill. Note that you can use special pattern-matching characters in an alias. Thus, the line: alias lprint 'pr \!* | lpr'
makes a command that formats its arguments to the line printer. The ! (exclamation point) is protected from the shell in the alias so that it is not expanded until pr runs.
If an alias is found, the word transformation of the input text is performed
and the aliasing process begins again on the reformed input line. If the first
word of the new text is the same as the old, looping is prevented by flagging
it to terminate the alias process. Other loops are detected and cause an error.
The shell maintains a set of variables, each of which has as its value a list of zero or more words. Some of these variables are set by the shell or referred to by it. For instance, the argv variable is an image of the shell variable list, and words that comprise the value of this variable are referred to in special ways.
You can display and change the values of variables by using the set and unset commands. Of the variables referred to by the shell, a number are toggles (variables that turn on and off); the shell does not care what their value is, only whether they are set or unset. For instance, the verbose variable is a toggle that causes the words of each command to be echoed. The setting of this variable results from the -v option on the command line.
Other operations treat variables numerically. The @ command performs numeric calculations and the result is assigned to a variable. Variable values are, however, always represented as (zero or more) strings. For the purposes of numeric operations, the null string is considered to be 0 (zero), and the second and subsequent words of multiword values are ignored.
After the input line is parsed and alias substitution is performed, and before each command is executed, variable substitution is performed, keyed by $ (dollar sign) characters. You can prevent this expansion by preceding the $ with a \ (backslash) except within " " (double quotes), where it always occurs, or by using ' ' (single quotes), where it never occurs. Strings quoted by ` ` (grave accents) are interpreted later (see Command Substitution), so variable substitution does not occur there until later, if at all. A $ is passed unchanged if followed by a space, tab, or newline.
Input/output redirection is recognized and expanded before variable expansion occurs. Otherwise, the command name and complete argument list are expanded together. Therefore, it is possible for the first (command) word to this point to generate more than one word, the first of which becomes the command name, and the rest of which become arguments.
Unless enclosed in " " or given the :q modifier, the results of variable substitution can themselves eventually be command and file name substituted. Within pairs of double quotes, 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 spaces. When you apply the :q modifier to a substitution, the variable expands to multiple words. The individual words are separated by spaces and quoted to prevent later command or file name substitution.
The following notation allows you to introduce variable values into the shell input. Except as noted, it is an error to reference a variable that is not set. Are replaced by the words assigned to the variable name, each separated by a space. Braces insulate name from following characters that would otherwise be part of it. Shell variable names begin with a letter and consist of up to 20 letters and digits, including the underscore character.
You can apply the modifiers :gh, :gt, :gr, :h, :t, :r, :q and :x to the preceding substitutions. If { } (braces) appear in the command form, the modifiers must appear within the braces. Note that the current implementation allows only one : (colon) modifier on each $ variable expansion.
The following substitutions cannot be changed with
:
modifiers.
Substitutes the string
1
if name is set,
0
if it is not.
Substitutes
1
if the current input file
name is known,
0
(zero) if it is not.
Substitutes the (decimal) process number of the (parent) shell.
Substitutes a line from the standard input, with no further
interpretation. Use it to read from the keyboard in a shell script.
The shell performs command and file name substitution selectively on
the arguments of built-in commands. This means that it does not expand those
parts of expressions that are not evaluated. For commands that are not internal
(that is, built in) to the shell, the shell substitutes the command name separately
from the argument list. This occurs very late, after the shell performs input/output
redirection, and in a child of the main shell.
The shell performs command substitution on a command string enclosed in ` ` (grave accents). The shell normally breaks the output from such a command into separate words at spaces, tabs and newline characters, with null words being discarded; this text then replaces the original command string. Within strings surrounded by " " (double quotes), the shell treats only the newline character as a word separator, thus preserving spaces and tabs.
In any case, the single final newline character does not force a new
word. Note that it is therefore possible for a command substitution to yield
only part of a word, even if the command outputs a complete line.
If a word contains any of the characters *, ?, [, or { or begins with a ~ (tilde), then that word is a candidate for file name substitution, also known as globbing. This word is then regarded as a pattern, and replaced with a sorted list of file names that match the pattern.
In a list of words specifying file name substitution, it is an error for no pattern to match an existing file name, but it is not required that each pattern match. Only the character-matching symbols (metacharacters) *, ? and [ imply pattern matching; the characters ~ and { are more like abbreviations.
In matching file names, the . (dot) character at the beginning of a file name or immediately following a / (slash), as well as the / character, must be matched explicitly. The * (asterisk) character matches any string of characters, including the null string. The ? (question mark) character matches any single character. The sequence [abcd] matches any one of the enclosed characters. Within [ ], a lexical range of characters can be indicated by two characters separated by a - (dash), as in [a-z]. The characters that match this pattern are defined by the current collating sequence. The collating sequence is determined by the value of the LC_COLLATE or LANG environment variable.
The ~ (tilde) character at the beginning of a file name is used to refer to home directories. Standing alone, the ~ expands to your home directory as reflected in the value of the home shell variable. When followed by a name that consists of letters, digits, and - (dash) characters, the shell searches for a user with that name and substitutes that user's home directory. Thus, ~ken might expand to /users/ken and ~ken/chmach to /users/ken/chmach. If the ~ (tilde) character is followed by a character other than a letter or / (slash) or does not appear at the beginning of a word, it is left undisturbed.
The pattern a{b,c,d}e is a shorthand for abe ace ade. Left-to-right order is preserved, with the results of the matches being sorted separately at a low level to preserve this order. This construct can be nested. Thus, the shell expands: ~source/s1/{oldls,ls}.c
to the file names: /usr/source/s1/oldls.c /usr/source/s1/ls.c
The preceding example assumes the home directory for source is /usr/source. (Note that these files may or may not exist.)
Similarly, the shell expands: ../{memo,*box}
to the paths: ../memo ../box ../mbox
(Note that
memo
was not sorted with the results of
matching
*box.) As a special case,
{,
}, and
{}
are passed undisturbed.
You can redirect the standard input and standard output of a command with the following syntax: Opens file (which is first variable, command and file name expanded) as the standard input. Reads the shell input up to a line that is identical to word. The word is not subjected to variable, file name or command substitution; each input line is compared to word before any substitutions are done on this input line. Unless a quoting character (\, ", `, or ') appears in word, the shell performs variable and command substitution on the intervening lines, allowing \ to quote $, \, and `. Commands that are substituted have all spaces, tabs, and newline characters preserved, except for the final newline character, which is dropped. The resulting text is placed in an anonymous temporary file and given to the command as standard input. Uses file as standard output. If the file does not exist, it is created; if the file exists, it is truncated, and its previous contents are lost.
A command receives the environment in which the shell was invoked, as changed by the input/output parameters and the presence of the command in a pipeline. Thus, unlike some previous shells, commands run from a shell script have no access to the text of the commands by default; rather they receive the original standard input of the shell. Use the << mechanism to present inline data. This lets shell scripts function as components of pipelines and lets the shell read its input in blocks.
To redirect diagnostic output through a pipe with the standard output,
use the form
|&
(vertical bar, ampersand) rather than
|
(vertical bar) alone.
The shell contains a number of commands that can be used to regulate the flow of control in command files (shell scripts) and (in limited but useful ways) from terminal input. These commands all operate by forcing the shell to reread or skip in its input and, because of the implementation, restrict the placement of some of the commands.
The foreach, switch, and while statements, and the if-then-else form of the if statement, require that the major keywords appear in a single simple command on an input line.
If the shell input is not seekable, the shell buffers input whenever
a loop is being read and performs seeks in the internal buffer to do the rereading
implied by the loop. (To the extent that this allows, backward
gotos succeed on non-seekable inputs.)
Built-in commands are executed within the shell. If a built-in command occurs as any component of a pipeline except the last, it is executed in a subshell. The csh searches for a csh built-in command first. If a built-in does not exist, the csh searches through the directories specified by the environment variable path for a system-level command to execute. If no arguments are specified, displays all aliases. If name is specified, displays the alias for name. If a word_list is also specified, alias assigns the specified word_list as the alias of name. Command and file name substitution are performed on word_list. Puts the current (if %job is not specified) or specified jobs into the background, continuing them if they were stopped. Causes execution to resume after the end of the nearest enclosing foreach or while. The remaining commands on the current line are executed. Multilevel breaks are therefore possible by writing them all on one line. Causes a break from a switch; resumes after the endsw. Defines a label in a switch statement. (See switch.) Changes the shell's working directory to directory. If no argument is given, it changes to your home directory.
The built-in commands @, exit, if, and while accept expressions that include operators similar to those of C, but with a precedence from right to left instead of from left to right. The following operators are available:
( ) ~ ! * / % + - << >> <= >= < > == != =~ !~ & ^ | && ||
In the preceding list, operators of equal precedence appear on the same line, below those lines containing operators (if any) that have greater precedence, and above those lines containing operators having lesser precedence. The ==, !=, =~, and !~ operators compare their arguments as strings; all others operate on numbers. The =~ and !~ operators are similar to != and ==, except that the rightmost side is a pattern against which the left-hand operand is matched. This reduces the need for use of the switch statement in shell scripts when all that is really needed is pattern matching.
Null or missing arguments are considered 0 (zero). The result of all expressions are strings, which represent decimal numbers. It is important to note that no two components of an expression can appear in the same word. Except when next to components of expressions that are syntactically significant to the parser (&, |, <, >, -, (, and ) ) expression components should be surrounded with spaces.
Also available in expressions as primitive operands are command executions enclosed in { and } and file inquiries of the form -l name where l is one of the following: Read access Write access Execute access Existence Ownership Zero size Plain file Directory Symbolic link
The specified file is command and file name expanded and then tested
to see if it has the specified relationship to the real user. If the file
does not exist or is inaccessible, then all inquiries return FALSE, that is,
0
(zero). Command executions succeed, returning TRUE (1), if the command exits with status 0 (zero); otherwise, they fail,
returning FALSE (0). If more detailed status information
is required, execute the command outside of an expression and examine the
status
shell variable.
The following variables have special meaning to the shell. Of these, argv, cwd, home, path, prompt, shell, and status are always set by the shell. Except for cwd and status, this setting occurs only at initialization; the remaining variables maintain their settings unless you explicitly reset them.
The csh command copies the USER environment variable into the variable user, TERM into term, and HOME into home, and copies these back into the environment whenever the normal shell variables are reset. The PATH environment variable is handled similarly; it is not necessary to worry about their settings other than in the .cshrc file. Each csh subprocess imports the definition of path from the environment, and exports it again if you then change it. Is set to the arguments to the shell. It is from this variable that positional parameters are substituted, for example, $1 is replaced by $argv[1], and so on. Gives a list of alternate directories to be searched to find subdirectories in chdir commands. Is set to the full path name of the current directory. Causes each command and its arguments to be echoed to standard output just before it is executed. It is set when the -x command line option is specified. For nonbuilt-in commands, all expansions occur before echoing. Built-in commands are echoed before command and file name substitution, since these substitutions are then done selectively. Enables file name completion. Changes the characters used in history substitution when given a string value. The first character of its value is used as the history substitution character, replacing the default character ! (exclamation point). The second character of its value replaces the character ^ (circumflex) in quick substitutions. Controls the existence and size of the history buffer. All commands (executable or not) are saved in the history buffer. Values of history that are too large can run the shell out of memory. The last executed command is always saved on the history list even if history is left unset. Contains the absolute path name to the home directory of the user, initialized from the environment. The file name expansion of ~ (tilde) refers to this variable. Causes the shell to ignore End-of-File characters from input devices that are terminals. This prevents shells from accidentally being killed when they read an End-of-File character. Specifies the locale of your system, which is comprised of three parts: language, territory, and codeset. The default locale is the C locale, which specifies the value English for language, U.S. for territory, and ASCII for codeset. The locale specified for the LANG variable controls the language applied to messages. Unless set explicitly, the LC_COLLATE, LC_CTYPE, LC_MESSAGES, LC_MONETARY, LC_NUMERIC, and LC_TIME variables also derive their settings from the locale set for LANG. Specifies the collating sequence to use when sorting names and when character ranges occur in patterns. The default value is the collating sequence for American English. Specifies the character classification information to use on your system. The default value is American English. Specifies the language that the system expects for user input of yes and no strings. The default value is American English. Specifies the monetary format for your system. The default value is the monetary format for American English. Specifies the numeric format for your system. The default value is the numeric format for American English. Specifies the date and time format for your system. The default value is the date and time format for American English. Specifies the files where the shell checks for mail. This is done after each command completion that results in a prompt, if a specified interval has elapsed. The shell displays the message You have new mail if the file has been modified since the last check.
%D | Kilobytes of data space |
%F | Number of page faults |
%K | Kilobytes of stack space |
%M | Total kilobytes of memory |
%W | Number of times the process was swapped |
%X | Kilobytes of text space |