csh.1

来自「<B>Digital的Unix操作系统VAX 4.2源码</B>」· 1 代码 · 共 2,332 行 · 第 1/5 页

.\" SCCSID: @(#)csh.1	3.4	9/14/88
.de sh
.br
.ne 5
.PP
\fB\\$1\fR
.PP
..
.if n .ds ua \o'^|'
.if t .ds ua \(ua
.if n .ds aa '
.if t .ds aa \(aa
.if n .ds ga `
.if t .ds ga \(ga
.if t .tr *\(**
.TH csh 1
.SH Name
csh \- C shell Command Interpreter
.SH Syntax
.B csh
[\fB\-cefinstvVxX\fR\|] [\|\fIarg...\fR\|]
.SH Description
.NXR "C shell" "See csh command interpreter"
.NXR "csh command interpreter"
The
.PN csh
command is a command language interpreter that consists of a history 
mechanism, job control facilities, and a C-like syntax.  While this 
command has a set of 
.I built-in
functions that it performs directly, the command line interpreter
also reads and translates commands that invokes other programs.
Additionally, you can create shell scripts which the
.PN csh
command can interpret.  Shell scripts are files which contain executable
instructions.
.PP
The percent sign (%) represents the system prompt.  It indicates
that you can begin entering commands to the system.  
Each command line that you type is read and broken into words.  
This sequence of words is placed on a command history list and
then parsed.  When the entire command line has executed, the
percent sign reappears and you can enter another command.  See the 
History Substitution and Jobs sections for more information.
.PP
To use the
.PN csh
command's full job control facilities, you must invoke the tty
driver described in 
.MS tty 4 .
This driver allows generation of interrupt characters from the
keyboard which stop execution of a job.  For details on setting
options in the tty driver, see
.MS stty 1 .
.PP
Note that your environment setup is controlled by commands in the
home directory of your .cshrc file.  The 
.PN csh
command executes these commands when you enter the system.  Additionally,
if this is a login shell, the Shell also executes the commands in
your .login file.  These files usually contain your options for the
tty driver and 
.MS tset 1 ,
(terminal settings).
When a login shell session ends, commands are executed from the .logout
file in your home directory.
.SH Lexical Structure
.NXR "csh command interpreter" "lexical structure"
The shell splits input lines into words at blanks and tabs with the
following exceptions:
.IP \(bu 5
ampersand (&)
.IP \(bu 5
bar ( | )
.IP \(bu 5
semicolon ( ; )
.IP \(bu 5
Left (<) and right (>) angle brackets
.IP \(bu 5
Left (() and right ()) parenthesis
.PP
The previous metacharacters form separate words.  If doubled as follows,
these metacharacters form single words:
.IP \(bu 5
Doubled ampersand (&&)
.IP \(bu 5
Double bars (||)
.IP \(bu 5
Double left (<<) and right (>>) brackets
.IP \(bu 5
Backslash (\e)
.IP \(bu 5
Single (\` \`) and double (" ") quotation marks.
.PP
Metacharacters can be a part of other words.  Additionally, if you do
not want a metacharacter to be 
interpreted as such by the system, you can
precede it with a backslash e (\\e).  A new line that is preceded by a
is equivalent to a blank.
.PP
Strings enclosed in single quotes (\` \`) or strings enclosed
in double quotes (" ") form parts of a word.  Metacharacters in these
strings, including blanks and tabs, do not form separate words.  This
is described in more detail later.  Within single quotes or double
quotes, a new line preceded by a backslash (\e) gives a true new line
character.
.PP
When the shell's input is not a terminal,
the pound sign (#) introduces a comment which continues to the end of the
input line.
It is prevented this special meaning when preceded by a backslash (\e)
and single or double quotation marks.
.SH Commands
.NXR "csh command interpreter" "command definition"
A command is a word or sequence of words that directs the system
to perform a certain function.  You can separate commands with
a bar ( | ) which forms a pipeline.  The output that results from
each command in the pipeline is connected to the input of the
next.  For example, in the following pipeline, a file is copied
and the output is piped to standard output (the screen):
.EX
% cp /example/dir/test . | more
.EE
You can form and execute several pipelines by separating each 
pipeline with a semicolon (;).  You can also force a command to
complete execution in the background by typing an ampersand (&) at
the end of the command line.
.PP
You can form a simple command (which may be a component of a
pipeline and so on) by placing any of the above in parenthesis
(()).  As in the C language, you can also separate pipelines
with a double bar (||) or double ampersands (&&).  The double
bar tells the command interpreter to execute the second
command only if the first command fails.  The double ampersands
tells the command interpreter to execute the second command if
the first command is successful.
.SH Jobs
.NXR "csh command interpreter" "running jobs"
The Shell associates each command or pipeline with a
.I job
index.  By typing
.B jobs
at the system prompt, a table of the current jobs is printed on
your screen.  Each job listed has a small integer number
associated with it.  
For example, if you force a job into the background using
an ampersand (&), the shell displays the job number and process 
id of that job as follows:
.EX
[1] 1234
.EE
.PP
In the previous example, the job number is 1 indicating that this
is a background job and the process id is 1234.
.PP
If you are running a job in the foreground, you can suspend
execution of that job by typing a CTRL/Z.  The Shell then indicates
that the job has been stopped and the system prompt reappears. If you
type jobs at the prompt, the display indicates that a job has
been stopped.  You can either enter another command at the prompt or you can 
manipulate the state of the job you suspended as follows:
.IP \(bu 5
Place the job in background by using the 
.B bg
command.
.IP \(bu 5
Continue to execute the job by placing it in the foreground using the
.B fg
command.
.PP
A CTRL/Z takes effect immediately and is like an interrupt.  For example,
pending output and unread output are discarded when the CTRL/Z is issued.
You can also type a CTRL/Y which does not generate a stop signal until
a program attempts to perform a
.MS read 2
operation.
.PP
If a job that is being run in the background attempts to read from
the terminal, it will stop.  Background jobs can produce output.  You
can prevent background jobs from producing output by issuing the
following command:
.EX
stty tostop
.EE
.PP
There are several ways to refer to jobs in the shell.  For example, to 
bring job number 1 into the foreground, 
type %1 or fg %1.  Similarly, %1 & returns job 1 to the 
background.  If a job does not have an ambiguous prefix, you can
restart a job by it's prefix.  For example, %ex would restart a
suspended
.PN ex
job, if it is the only suspended 
.PN ex
job.  You use also use %?\fIstring\fR which specifies a job whose command
line contains
.I string. 
Again, 
.I string 
cannot 
be an ambiguous name. 
.PP
The Shell tracks the current and previous jobs.  For example,
in output displays of jobs, the current job is marked with
a plus sign (+) and the previous job is marked with a minus
sign (-).  Hence, you can type %+ for the current job and %-
for the previous job.  You can also specify %% which specifies
the current job.
.SH Status Reporting
.NXR "csh command interpreter" "reporting job status"
The Shell performs status reporting when the process state
changes.  For example, if a job becomes blocked and further
processing is not possible, the Shell informs you just before
it prints a prompt.  If, however, you set the Shell variable
.I notify,
the Shell provides you with immediate status of background jobs.
As opposed to notifying you of all changes in background jobs,
the Shell command 
.I notify
can mark a single process so that only its status change is reported.
To mark a single file, type notify after starting a background
job.  By default, only the current process is marked.
.PP
If you try to exit from the Shell while jobs are stopped, the
following warning appears:
.EX
You have stopped jobs.
.EE
.PP
You can use the 
.B jobs
command to view the stopped jobs. If you immediately try to
exit again, the Shell does not provide a second warning and
suspended jobs are terminated.
.SH Substitutions
The various transformations the shell performs on the input is now
described in the order in which they occur.
.SH History Substitutions
.NXR "csh command interpreter" "repeating commands"
History substitutions allow you to use words from previously typed
commands as portions of new commands.  This enables you to repeat
commands, arguments, or fix spelling mistakes from the previous command.
.PP
An exclamation point (!) marks the beginning of a history 
substitution.  It can appear anywhere in the input stream (including
the beginning) as long as it is not nested.  An input line that
contains history substitution is echoed to the screen before it is
executed.
.PP
The exclamation point (!) may be preceded by a backslash (\e) if
you want to escape its special meaning.  If an exclamation point
is followed by a blank, tab, new line, equal sign (=), or left
parenthesis ((), it is passed unchanged.
.PP
Any command line that is typed at the terminal is saved on the
history list.  You can increase or decrease the size of your
history list using the
.I history
variable; the previous command is always retained regardless of its value.
Commands are numbered sequentially from 1. To display the history
on your terminal, type history at the prompt as follows:
.EX
% history
.EE
.PP
This command lists the commands that were previously typed.  For example:
.EX
1  write michael
2  ex write.c
3  cat oldwrite.c
4  diff*write.c
.EE
.PP
The commands are shown with their event numbers.  Although it is not usually
necessary to use event numbers, you can reinvoke any command by combining
the exclamation point (!) with any event number.  For example, if you are
referencing the previous history list, !4 reinvokes the command line 
diff*write.c.  You can also reinvoke a command without the event number
as long as it is not ambiguous.  For example, !c invokes event 3 or !wri 
invokes event 1.  The line !?mic? also refers to event 1.  If you type
!!, the last command entered in reinvoked.
.PP
To select words from an event, follow the event specification with 
a colon (:) and a designator for the desired words.
The words of a input line are numbered from 0, 
the first (usually command) word being 0, the second word (first argument)
being 1, and so forth.
The basic word designators are:
.PP
.DT
.nf
	0	first (command) word
	\fIn\fR	\fIn\fR\|'th argument
	!	first argument,  that is `1'
	$	last argument
	%	word matched by (immediately preceding) ?\fIs\fR\|? search
	\fIx\fR\|\-\fIy\fR	range of words
	\-\fIy\fR	abbreviates `0\-\fIy\fR\|'
	*	abbreviates `!-$', or nothing if only 1 word in event
	\fIx\fR\|*	abbreviates `\fIx\fR\|\-$'
	\fIx\fR\|\-	like `\fIx\fR\|*' but omitting word `$'
.fi
.PP
The colon (:) separating the event specification from the word designator
can be omitted if the argument selector begins with a `!', `$', `*'
`\-' or `%'.
After the optional word designator can be
placed a sequence of modifiers, each preceded by a colon (:).
The following modifiers are defined:
.ta .5i 1.2i
.PP
.nf
	h	Remove a trailing pathname component, leaving the head.
	r	Remove a trailing `.xxx' component, leaving the root name.
	e	Remove all but the extension `.xxx' part.
	s/\fIl\fR\|/\fIr\fR\|/	Substitute \fIl\fR for \fIr\fR
	t	Remove all leading pathname components, leaving the tail.
	&	Repeat the previous substitution.
	g	Apply the change globally, prefixing the above, for example, `g&'.
	p	Print the new command but do not execute it.
	q	Quote the substituted words, preventing further substitutions.
	x	Like q, but break into words at blanks, tabs and new lines.
.fi
.PP
Unless preceded by a `g' the modification is applied only to the first
modifiable word.  With substitutions, it is an error for no word to be
applicable.
.PP
The left hand side of substitutions are not regular expressions in the sense
of the editors, but rather strings.
Any character may be used as the delimiter in place of `/';
a `\e' quotes the delimiter into the
.IR l ""
and
.IR r ""
strings.
The character `&' in the right hand side is replaced by the text from
the left.
A `\e' quotes `&' also.
A null
.IR l ""
uses the previous string either from a
.IR l ""
or from a
contextual scan string
.IR s ""
in `!?\fIs\fR\|?'.
The trailing delimiter in the substitution may be omitted if a new line
follows immediately as may the trailing `?' in a contextual scan.
.PP
A special abbreviation of a history reference occurs when the first
non-blank 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^' fixes the spelling of lb in the previous command.
Finally, a history substitution may be surrounded with `{' and `}'
if necessary to insulate it from the characters which follow.
Thus, after `ls \-ld ~paul' we might do `!{l}a' to do `ls \-ld ~paula',
while `!la' would look for a command starting `la'.
.PP
.if n .ul
\fBQuotations\ with\ \'\ and\ "\fR
.NXR "csh command interpreter" "quoted strings and"
.PP
The quotation of strings by `\'' and `"' can be used
to prevent all or some of the remaining substitutions.
Strings enclosed in `\'' are prevented any further interpretation.
Strings enclosed in `"' may be expanded as described below.
.PP
In both cases the resulting text becomes (all or part of) a single word;
only in one special case (see
.I "Command Substitution"
below) does a `"' quoted string yield parts of more than one word;
`\'' quoted strings never do.
.SH Alias Substitution
.NXR "csh command interpreter" "substituting an alias"
The shell maintains a list of aliases that can be established, displayed,
and modified by the
.I alias
and
.I unalias
commands. 
.PP
After the shell scans a command line, it parses the line into
distinct commands. Then, the shell checks the first word of each
command, in left-to-right order, to determine if the command line
contains an alias. When the shell finds an alias, it substitutes the
definition of the alias for the alias in the command line. The shell
reads the definition of the alias using the history mechanism and
treats the definition as if it was the previous input line.
If the alias definition makes no reference to the history list, the
shell leaves the command's argument unchanged.
.PP
For example, the following command creates an alias called ``ls:''
.EX
% alias ls \'ls \-l\'
.EE
After you issue this 
.I alias
command, you receive information about files such as their mode, 
number of links,
owner, and so on when you use the ls alias.
For example, the following shows the output from the ls
alias created in the preceeding example:
.EX
% ls \/usr\/smith\/text_file
-rw-r--r--  1 smith          21 Mar 12 11:53 text_file
.EE
You can also create aliases that allow you to supply arguments on the
command line and arguments in the alias definition, as shown
in the following example:
.EX
% alias lookup \'grep \e!^ /etc/passwd\' 
.EE
You must specify ``\\'' before the \*Q!\*U to prevent the substitution
from occurring in the 
.I alias 
command. The following shows the output from the lookup alias:
.EX
% lookup smith
smith:2vruqPosbG/bE:1321:10::\/usr\/smith:\/bin\/csh
.EE
The lookup alias finds and displays user Smith's entry in the
.PN /etc/passwd 
file.
.PP
You can specify an alias within an alias definition. After the shell
finds an alias and substitutes its definition, it searches again for aliases. 
The shell flags definitions that begin with the same word as the
alias to prevent infinite loops. Other loops are detected and cause an
error. 
.PP
You can use parser metasyntax in an 
.I alias
command. For example, the following is a valid command that creates the
print alias:
.EX 
% alias print \'pr \e!* \||\| lpr\' 
.EE
The print alias pipes output from the
.PN pr
command to the
.PN lpr
command.
.SH Variable Substitution
.NXR "csh command interpreter" "variable substitution"
The shell maintains a set of variables, each of which has as 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
.I argv
variable is an image of the shell's argument list, and words of this
variable's value are referred to in special ways.
.PP
The values of variables may be displayed and changed by using the
.I set
and
.I unset
commands.
Of the variables referred to by the shell a number are toggles;
the shell does not care what their value is,
only whether they are set or not.
For instance, the
.I verbose
variable is a toggle which causes command input to be echoed.
The setting of this variable results from the
.B \-v