Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
csh(1)				 User Commands				csh(1)

NAME
       csh - shell command interpreter with a C-like syntax

SYNOPSIS
       csh [-bcefinstvVxX] [argument...]

DESCRIPTION
       csh, the	C shell, is a command interpreter with a syntax	reminiscent of
       the C language. It provides a number of convenient features for	inter-
       active  use  that  are  not  available with the Bourne shell, including
       filename	completion, command aliasing, history substitution,  job  con-
       trol,  and a number of built-in commands. As with the Bourne shell, the
       C shell provides	variable, command and filename substitution.

   Initialization and Termination
       When first started, the C shell normally	 performs  commands  from  the
       .cshrc  file  in	 your home directory, provided that it is readable and
       you either own it or your real group ID matches its group  ID.  If  the
       shell  is  invoked with a name that starts with `-', as when started by
       login(1), the shell runs	as a login shell.

       If the shell is a login shell, this is  the  sequence  of  invocations:
       First,  commands	 in  /etc/.login are executed. Next, commands from the
       .cshrc file your	home directory are executed. Then the  shell  executes
       commands	 from the .login file in your home directory; the same permis-
       sion checks as those for	.cshrc are applied to  this  file.  Typically,
       the  .login file	contains commands to specify the terminal type and en-
       vironment. (For an explanation of file interpreters, see	below "Command
       Execution" and exec(2).)

       As a login shell	terminates, it performs	commands from the .logout file
       in your home directory; the same	permission checks as those for	.cshrc
       are applied to this file.

   Interactive Operation
       After  startup  processing  is  complete, an interactive	C shell	begins
       reading commands	from the terminal, prompting with hostname% (or	 host-
       name#  for the privileged user).	The shell then repeatedly performs the
       following actions: a line of command input  is  read  and  broken  into
       words.  This  sequence  of words	is placed on the history list and then
       parsed, as described under USAGE, below.	Finally,  the  shell  executes
       each command in the current line.

   Noninteractive Operation
       When running noninteractively, the shell	does not prompt	for input from
       the terminal. A noninteractive C	shell can execute a  command  supplied
       as  an argument on its command line, or interpret commands from a file,
       also known as a script.

OPTIONS
       The following options are supported:

       -b    Force a "break" from option processing. Subsequent	 command  line
	     arguments are not interpreted as C	shell options. This allows the
	     passing of	options	to a script without confusion. The shell  does
	     not run set-user-ID or set-group-ID scripts unless	this option is
	     present.

       -c    Execute the first argument	(which must be present). Remaining ar-
	     guments  are  placed  in  argv,  the  argument-list variable, and
	     passed directly to	csh.

       -e    Exit if a command terminates abnormally or	yields a nonzero  exit
	     status.

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

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

       -n    Parse (interpret),	but do not execute commands. This  option  can
	     be	used to	check C	shell scripts for syntax errors.

       -s    Take commands from	the standard input.

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

       -v    Verbose.  Set  the	 verbose predefined variable; command input is
	     echoed after history substitution	(but  before  other  substitu-
	     tions) and	before execution.

       -V    Set verbose before	reading	.cshrc.

       -x    Echo.  Set	 the  echo variable; echo commands after all substitu-
	     tions and just before execution.

       -X    Set echo before reading .cshrc.

       Except with the options -c, -i, -s, or -t, the first nonoption argument
       is  taken  to be	the name of a command or script. It is passed as argu-
       ment zero, and subsequent arguments are added to	the argument list  for
       that command or script.

USAGE
   Filename Completion
       When  enabled by	setting	the variable filec, an interactive C shell can
       complete	a partially typed filename or user name. When  an  unambiguous
       partial	filename is followed by	an ESC character on the	terminal input
       line, the shell fills in	the remaining characters of a  matching	 file-
       name from the working directory.

       If  a  partial filename is followed by the EOF character	(usually typed
       as CTRL-d), the shell lists all filenames that match. It	 then  prompts
       once again, supplying the incomplete command line typed in so far.

       When  the  last	(partial)  word	begins with a tilde (~), the shell at-
       tempts completion with a	user name, rather than a file in  the  working
       directory.

       The  terminal  bell signals errors or multiple matches; this can	be in-
       hibited by setting the variable nobeep. You can exclude files with cer-
       tain  suffixes  by  listing those suffixes in the variable fignore. If,
       however,	the only possible completion includes a	suffix in the list, it
       is not ignored. fignore does not	affect the listing of filenames	by the
       EOF character.

   Lexical Structure
       The shell splits	input lines into words at space	 and  tab  characters,
       except as noted below. The characters &,	|, ;, <, >, (, and ) form sep-
       arate words; if paired,	the  pairs  form  single  words.  These	 shell
       metacharacters can be made part of other	words, and their special mean-
       ing can be suppressed by	preceding them with a `\' (backslash). A  new-
       line preceded by	a \ is equivalent to a space character.

       In  addition,  a	string enclosed	in matched pairs of single-quotes ('),
       double-quotes ("), or backquotes	(`), forms a partial word; metacharac-
       ters  in	 such  a string, including any space or	tab characters,	do not
       form separate words. Within pairs of backquote (`) or double-quote  (")
       characters,  a  newline preceded	by a `\' (backslash) gives a true new-
       line character. Additional functions of each  type  of  quote  are  de-
       scribed,	 below,	under Variable Substitution, Command Substitution, and
       Filename	Substitution.

       When the	shell's	input is not a terminal, the character # introduces  a
       comment	that continues to the end of the input line. Its special mean-
       ing is suppressed when preceded by a \ or enclosed in matching quotes.

   Command Line	Parsing
       A simple	command	is composed of a sequence of  words.  The  first  word
       (that  is  not  part of an I/O redirection) specifies the command to be
       executed. A simple command, or a	set of simple commands separated by  |
       or  |& characters, forms	a pipeline. With |, the	standard output	of the
       preceding command is redirected to the standard input  of  the  command
       that  follows. With |&, both the	standard error and the standard	output
       are redirected through the pipeline.

       Pipelines can be	separated by semicolons	(;), in	which  case  they  are
       executed	 sequentially.	Pipelines  that	are separated by && or || form
       conditional sequences in	which the execution of pipelines on the	 right
       depends	upon  the success or failure, respectively, of the pipeline on
       the left.

       A pipeline or sequence can be enclosed within parentheses `()' to  form
       a simple	command	that can be a component	in a pipeline or sequence.

       A sequence of pipelines can be executed asynchronously or "in the back-
       ground" by appending an `&'; rather than	waiting	for  the  sequence  to
       finish  before issuing a	prompt,	the shell displays the job number (see
       Job Control, below) and associated process IDs and prompts immediately.

   History Substitution
       History substitution allows you to  use	words  from  previous  command
       lines in	the command line you are typing. This simplifies spelling cor-
       rections	and the	repetition of complicated commands or arguments.  Com-
       mand  lines  are	 saved	in the history list, the size of which is con-
       trolled by the history variable.	The most recent	command	is retained in
       any  case.  A  history  substitution  begins with a ! (although you can
       change this with	the histchars variable)	and may	occur anywhere on  the
       command	line; history substitutions do not nest. The !	can be escaped
       with \ to suppress its special meaning.

       Input lines containing history substitutions are	echoed on the terminal
       after  being expanded, but before any other substitutions take place or
       the command gets	executed.

   Event Designators
       An event	designator is a	reference to a command line entry in the  his-
       tory list.

       !     Start  a  history	substitution,  except when followed by a space
	     character,	tab, newline, =	or (.

       !!    Refer to the previous command. By itself, this  substitution  re-
	     peats the previous	command.

       !n    Refer to command line n.

       !-n   Refer to the current command line minus n.

       !str  Refer to the most recent command starting with str.

       !?str?
	     Refer to the most recent command containing str.

       !?str? additional
	     Refer  to the most	recent command containing str and append addi-
	     tional to that referenced command.

       !{command} additional
	     Refer to the most recent command beginning	with command  and  ap-
	     pend additional to	that referenced	command.

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

	     !:s/previous_word/replacement/.

	     To	re-execute a specific previous command AND make	such a substi-
	     tution, say, re-executing command #6,

	     !:6s/previous_word/replacement/.

   Word	Designators
       A `:' (colon) separates the event specification from the	word  designa-
       tor.  It	can be omitted if the word designator begins with a ^, $, *, -
       or %. If	the word is to be selected from	the previous command, the sec-
       ond  !  character can be	omitted	from the event specification.  For in-
       stance, !!:1 and	!:1 both refer to the first word of the	previous  com-
       mand, while !!$ and !$ both refer to the	last word in the previous com-
       mand. Word designators include:

       #     The entire	command	line typed so far.

       0     The first input word (command).

       n     The n'th argument.

       ^     The first argument, that is, 1.

       $     The last argument.

       %     The word matched by (the most recent) ?s search.

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

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

       x*    Abbreviates x-$.

       x-    Like x* but omitting word $.

   Modifiers
       After  the  optional  word designator, you can add one of the following
       modifiers, preceded by a	:.

       h     Remove a trailing pathname	component, leaving the head.

       r     Remove a trailing suffix of the form `.xxx',  leaving  the	 base-
	     name.

       e     Remove all	but the	suffix,	leaving	the Extension.

       s/l/r/
	     Substitute	r for l.

       t     Remove all	leading	pathname components, leaving the tail.

       &     Repeat the	previous substitution.

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

       p     Print the new command but do not execute it.

       q     Quote the substituted words, escaping further substitutions.

       x     Like q, but break into words at each space	character, tab or new-
	     line.

       Unless  preceded	 by a g, the modification is applied only to the first
       string that matches l; an error results if no string matches.

       The left-hand side of substitutions are not  regular  expressions,  but
       character  strings. Any character can be	used as	the delimiter in place
       of /. A backslash quotes	the delimiter character. The character	&,  in
       the  right  hand	side, is replaced by the text from the left-hand-side.
       The & can be quoted with	a backslash. A null l uses the previous	string
       either  from  a l or from a contextual scan string s from !?s.  You can
       omit the	rightmost delimiter if a newline immediately  follows  r;  the
       rightmost ? in a	context	scan can similarly be omitted.

       Without	an  event  specification, a history reference refers either to
       the previous command, or	to a previous history reference	on the command
       line (if	any).

   Quick Substitution
       ^l^r^ This is equivalent	to the history substitution: !:s/l/r/.

   Aliases
       The  C  shell maintains a list of aliases that you can create, display,
       and modify using	the alias and unalias commands.	The shell  checks  the
       first word in each command to see if it matches the name	of an existing
       alias. If it does, the command is reprocessed with the alias definition
       replacing  its  name; the history substitution mechanism	is made	avail-
       able as though that command were	the previous input line.  This	allows
       history	substitutions,	escaped	with a backslash in the	definition, to
       be replaced with	actual command line arguments when the alias is	 used.
       If  no  history	substitution  is  called for, the arguments remain un-
       changed.

       Aliases can be nested. That is, an alias	 definition  can  contain  the
       name  of	 another alias.	Nested aliases are expanded before any history
       substitutions is	applied. This is useful	in pipelines such as

       alias lm	'ls -l \!* | more'

       which when called, pipes	the output of ls(1) through more(1).

       Except for the first word, the name of the alias	may not	appear in  its
       definition,  nor	in any alias referred to by its	definition. Such loops
       are detected, and cause an error	message.

   I/O Redirection
       The following metacharacters indicate that the subsequent word  is  the
       name  of	a file to which	the command's standard input, standard output,
       or standard error is redirected;	this word is  variable,	 command,  and
       filename	expanded separately from the rest of the command.

       <     Redirect the standard input.

       <<word
	     Read  the	standard  input,  up  to a line	that is	identical with
	     word, and place the resulting lines in a temporary	 file.	Unless
	     word is escaped or	quoted,	variable and command substitutions are
	     performed on these	lines. Then, 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  ex-
	     ist, it is	created. If it does exist, it is overwritten; its pre-
	     vious 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.

   Variable Substitution
       The C shell maintains a set of variables, each of which is composed  of
       a  name	and  a value. A	variable name consists of up to	20 letters and
       digits, and starts with a letter	(the underscore	is considered  a  let-
       ter).  A	 variable's  value  is	a space-separated list of zero or more
       words.

       To refer	to a variable's	value, precede its name	with  a	 `$'.  Certain
       references  (described below) can be used to select specific words from
       the value, or to	display	other information about	the  variable.	Braces
       can  be	used to	insulate the reference from other characters in	an in-
       put-line	word.

       Variable	substitution takes place after the  input  line	 is  analyzed,
       aliases	are  resolved, and I/O redirections are	applied. Exceptions to
       this are	variable references in I/O redirections	 (substituted  at  the
       time the	redirection is made), and backquoted strings (see Command Sub-
       stitution).

       Variable	substitution can be suppressed by preceding the	$  with	 a  \,
       except  within double-quotes where it always occurs. Variable substitu-
       tion is suppressed inside of single-quotes. A $ is escaped if  followed
       by a space character, tab or newline.

       Variables can be	created, displayed, or destroyed using the set and un-
       set commands. Some variables are	maintained or used by the  shell.  For
       instance,  the  argv variable contains an image of the shell's argument
       list. Of	the variables used by the shell, a  number  are	 toggles;  the
       shell  does  not	care what their	value is, only whether they are	set or
       not.

       Numerical values	can be operated	on as numbers (as with the @  built-in
       command).  With	numeric	operations, an empty value is considered to be
       zero; the second	and subsequent words of	multiword values are  ignored.
       For  instance, when the verbose variable	is set to any value (including
       an empty	value),	command	input is echoed	on the terminal.

       Command and filename substitution is subsequently applied to the	 words
       that  result  from the variable substitution, except when suppressed by
       double-quotes, when noglob is set (suppressing filename	substitution),
       or  when	 the  reference	is quoted with the :q modifier.	Within double-
       quotes, a reference is expanded to form (a portion of) a	quoted string;
       multiword  values  are expanded to a string with	embedded space charac-
       ters. When the :q modifier is applied to	the reference, it is  expanded
       to  a list of space-separated words, each of which is quoted to prevent
       subsequent command or filename substitutions.

       Except as noted below, it is an error to	refer to a  variable  that  is
       not set.

       $var

       ${var}
	     These are replaced	by words from the value	of var,	each separated
	     by	a space	character. If var  is  an  environment	variable,  its
	     value  is	returned  (but `:' modifiers and the other forms given
	     below are not available).

       $var[index]

       ${var [index]}
	     These select only the indicated words  from  the  value  of  var.
	     Variable  substitution  is	applied	to index, which	may consist of
	     (or result	in) a either single number, two	numbers	separated by a
	     `-', or an	asterisk. Words	are indexed starting from 1; a `*' se-
	     lects all words. If the first number of a range  is  omitted  (as
	     with  $argv[-2]), it defaults to 1. If the	last number of a range
	     is	omitted	(as with $argv[1-]), it	defaults to  $#var  (the  word
	     count).  It is not	an error for a range to	be empty if the	second
	     argument is omitted (or within range).

       $#name

       ${#name}
	     These give	the number of words in the variable.

       $0    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.

       $n

       ${n}  Equivalent	to $argv[n].

       $*    Equivalent	to $argv[*].

       The modifiers :e, :h, :q, :r, :t, and :x	can be	applied	 (see  History
       Substitution),  as can :gh, :gt,	and :gr. If {} (braces)	are used, then
       the modifiers must appear within	the braces. The	current	implementation
       allows only one such modifier per expansion.

       The following references	may not	be modified with : modifiers.

       $?var

       ${?var}
	     Substitutes the string 1 if var is	set or 0 if it is not set.

       $?0   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  in-
	     terpretation thereafter. It can be	used to	read from the keyboard
	     in	a C shell script.

   Command and Filename	Substitutions
       Command and filename substitutions are applied selectively to the argu-
       ments of	built-in commands. Portions of expressions that	are not	evalu-
       ated are	not expanded. For non-built-in commands, filename expansion of
       the command name	is done	separately from	that of	the argument list; ex-
       pansion occurs in a subshell, after I/O redirection is performed.

   Command Substitution
       A command enclosed by backquotes	(`...`)	is performed  by  a  subshell.
       Its standard output is broken into separate words at each space charac-
       ter, tab	and newline; null words	are discarded. This text replaces  the
       backquoted  string  on  the current command line. Within	double-quotes,
       only newline characters force new words;	space and tab  characters  are
       preserved.  However, a final newline is ignored.	It is therefore	possi-
       ble for a command substitution to yield a partial word.

   Filename Substitution
       Unquoted	words containing any of	the characters *, ?, [ or {,  or  that
       begin  with  ~,	are expanded (also known as globbing) to an alphabeti-
       cally sorted list of filenames, as follows:

       *     Match any (zero or	more) characters.

       ?     Match any single character.

       [...] Match any single character	in the enclosed	list(s)	or range(s). A
	     list  is a	string of characters.  A range is two characters sepa-
	     rated by a	dash (-), and includes all the characters  in  between
	     in	the ASCII collating sequence (see ascii(5)).

       { str, str, ... }
	     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 in-
	     stance, {b,a} expands to `b'  `a',	 (not  `a'  `b').  As  special
	     cases,  the  characters  {	 and  }, along with the	string {}, are
	     passed undisturbed.

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

       Only the	patterns *, ? and [...]	imply pattern matching;	an  error  re-
       sults if	no filename matches a pattern that contains them. The `.' (dot
       character), when	it is the first	character in a	filename  or  pathname
       component,  must	 be  matched  explicitly.  The	/ (slash) must also be
       matched explicitly.

   Expressions and Operators
       A number	of C shell built-in commands accept expressions, in which  the
       operators are similar to	those of C and have the	same precedence. These
       expressions typically appear in the @, exit, if,	 set  and  while  com-
       mands, and are often used to regulate the flow of control for executing
       commands. Components of an expression are separated by white space.

       Null or missing values are considered 0.	The result of all  expressions
       is a string, which may represent	decimal	numbers.

       The following C shell operators are grouped in order of precedence:

       (...) grouping

       >~    one's complement

       !     logical negation

       *   /   %
	     multiplication, division, remainder (these	are right associative,
	     which can lead to unexpected results; group combinations  explic-
	     itly 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  (de-
	     scribed below), filename-substitution pattern mismatch

       &     bitwise AND

       ^     bitwise XOR (exclusive or)

       |     bitwise inclusive OR

       &&    logical AND

       ||    logical OR

       The  operators:	==, !=,	=~, and	!~ compare their arguments as strings;
       other operators use numbers. The	operators =~ and !~ each check whether
       or  not a string	to the left matches a filename substitution pattern on
       the right. This reduces the need	for switch  statements	when  pattern-
       matching	between	strings	is all that is required.

       Also available are file inquiries:

       -r filename
	     Return  true,  or 1 if the	user has read access. Otherwise	it re-
	     turns false, or 0.

       -w filename
	     True if the user has write	access.

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

       -e filename
	     True if filename exists.

       -o filename
	     True if the user owns filename.

       -z filename
	     True if filename is of zero length	(empty).

       -f filename
	     True if filename is a plain file.

       -d filename
	     True if filename is a directory.

       If  filename  does not exist or is inaccessible,	then all inquiries re-
       turn false.

       An inquiry as to	the success of a command is also available:

       { command }
	     If	command	runs successfully, the expression evaluates  to	 true,
	     1.	 Otherwise, it evaluates to false, 0. (Note:  Conversely, com-
	     mand itself typically returns 0 when  it  runs  successfully,  or
	     some  other  value	if it encounters a problem. If you want	to get
	     at	the status directly, use the  value  of	 the  status  variable
	     rather than this expression).

   Control Flow
       The shell contains a number of commands to regulate the flow of control
       in scripts and within limits, from the terminal.	These commands operate
       by forcing the shell either to reread input (to loop), or to skip input
       under certain conditions	(to branch).

       Each occurrence of a foreach, switch, while, if...then and else	built-
       in command must appear as the first word	on its own input line.

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

   Command Execution
       If the command is a C shell built-in command, the shell executes	it di-
       rectly. Otherwise, the shell searches for a file	by that	name with exe-
       cute access. If the command name	contains a /, the shell	takes it as  a
       pathname,  and  searches	for it.	If the command name does not contain a
       /, the shell attempts to	resolve	it to a	pathname, searching  each  di-
       rectory	in the path variable for the command. To speed the search, the
       shell uses its hash table (see the rehash built-in command)  to	elimi-
       nate  directories  that	have  no applicable files. This	hashing	can be
       disabled	with the -c or -t, options, or the unhash built-in command.

       As a special case, if there is no / in the name of the script and there
       is  an  alias  for  the word shell, the expansion of the	shell alias is
       prepended (without modification)	to the command line.  The  system  at-
       tempts  to  execute  the	 first	word  of this special (late-occurring)
       alias, which should be a	full pathname. Remaining words of the  alias's
       definition, along with the text of the input line, are treated as argu-
       ments.

       When a pathname is found	that has proper	execute	permissions, the shell
       forks  a	 new  process  and passes it, along with its arguments,	to the
       kernel using the	execve() system	call (see exec(2)).  The  kernel  then
       attempts	 to  overlay  the new process with the desired program.	If the
       file is an executable binary (in	a.out(4) format) the  kernel  succeeds
       and  begins  executing  the new process.	If the file is a text file and
       the first line begins with #!, the next word is taken to	be  the	 path-
       name of a shell (or command) to interpret that script. Subsequent words
       on the first line are taken as options for that shell. The  kernel  in-
       vokes  (overlays)  the indicated	shell, using the name of the script as
       an argument.

       If neither of the above conditions holds, the kernel cannot overlay the
       file  and  the  execve()	call fails (see	exec(2)); the C	shell then at-
       tempts to execute the file by spawning a	new shell, as follows:

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

	  o  Otherwise,	a Bourne shell is invoked.

   Signal Handling
       The shell normally ignores QUIT signals.	Background jobs	are immune  to
       signals	generated  from	 the  keyboard,	including hangups (HUP). Other
       signals have the	values that the	C shell	inherited  from	 its  environ-
       ment.  The  shell's  handling of	interrupt and terminate	signals	within
       scripts can be controlled by the	onintr built-in	command. Login	shells
       catch  the  TERM	 signal;  otherwise, this signal is passed on to child
       processes. In no	case are interrupts allowed  when  a  login  shell  is
       reading the .logout file.

   Job Control
       The  shell associates a numbered	job with each command sequence to keep
       track of	those commands that are	running	in the background or have been
       stopped with TSTP signals (typically CTRL-z). When a command or command
       sequence	(semicolon separated list) is started in the background	 using
       the  &  metacharacter, the shell	displays a line	with the job number in
       brackets	and a list of associated process numbers:

       [1] 1234

       To see the current list of jobs,	use the	jobs built-in command. The job
       most  recently stopped (or put into the background if none are stopped)
       is referred to as the current job and is	indicated with a `+'. The pre-
       vious  job  is indicated	with a `-'; when the current job is terminated
       or moved	to the foreground, this	job takes its place (becomes  the  new
       current job).

       To  manipulate  jobs,  refer  to	the bg,	fg, kill, stop,	and % built-in
       commands.

       A reference to a	job begins with	a `%'.	By  itself,  the  percent-sign
       refers to the current job.

       %   %+	%%
	     The current job.

       %-    The previous job.

       %j    Refer  to	job j as in: `kill -9 %j'. j can be a job number, or a
	     string that uniquely specifies the	command	line by	which  it  was
	     started; `fg %vi' might bring a stopped vi	job to the foreground,
	     for instance.

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

       A job running in	the background stops when it attempts to read from the
       terminal. Background jobs can normally produce output, but this can  be
       suppressed using	the `stty tostop' command.

   Status Reporting
       While  running  interactively,  the shell tracks	the status of each job
       and reports whenever the	job finishes or	becomes	blocked.  It  normally
       displays	 a  message  to	this effect as it issues a prompt, in order to
       avoid disturbing	the appearance of your input.  When  set,  the	notify
       variable	 indicates  that the shell is to report	status changes immedi-
       ately. By default, the notify command marks the current process;	 after
       starting	a background job, type notify to mark it.

   Commands
       Built-in	 commands  are executed	within the C shell. If a built-in com-
       mand occurs as any component of a pipeline except the last, it is  exe-
       cuted in	a subshell.

       :     Null  command.  This  command is interpreted, but performs	no ac-
	     tion.

       alias [ name [ def ] ]
	     Assign def	to the alias name. def is a list  of  words  that  may
	     contain  escaped history-substitution metasyntax. name is not al-
	     lowed to be alias or unalias. If def is omitted, the current def-
	     inition for the alias name	is displayed. If both name and def are
	     omitted, all aliases are displayed	with their definitions.

       bg [ %job ... ]
	     Run the current or	specified jobs in the background.

       break Resume execution after the	end of the nearest  enclosing  foreach
	     or	 while	loop.	The remaining commands on the current line are
	     executed. This allows multilevel breaks to	be written as  a  list
	     of	break commands,	all on one line.

       breaksw
	     Break from	a switch, resuming after the endsw.

       case label:
	     A label in	a switch statement.

       cd [dir ]

       chdir [dir ]
	     Change  the shell's working directory to directory	dir. If	no ar-
	     gument is given, change to	the home directory of the user.	If dir
	     is	 a relative pathname not found in the current directory, check
	     for it in those directories listed	in the cdpath variable.	If dir
	     is	 the  name  of	a  shell variable whose	value starts with a /,
	     change to the directory named by that value.

       continue
	     Continue execution	of the next iteration of the nearest enclosing
	     while or foreach loop.

       default:
	     Labels the	default	case in	a switch statement. The	default	should
	     come after	all case labels.  Any remaining	commands on  the  com-
	     mand line are first executed.

       dirs [-l]
	     Print the directory stack,	most recent to the left; the first di-
	     rectory shown is the current directory.  With  the	 -l  argument,
	     produce  an unabbreviated printout; use of	the ~ notation is sup-
	     pressed.

       echo [-n] list
	     The words in list are written to  the  shell's  standard  output,
	     separated	by  space  characters. The output is terminated	with a
	     newline unless the	-n option is used. csh will, by	 default,  in-
	     voke  its built-in	echo, if echo is called	without	the full path-
	     name of a Unix command, regardless	of the configuration  of  your
	     PATH (see echo(1)).

       eval argument...
	     Reads  the	 arguments  as input to	the shell and executes the re-
	     sulting command(s). This is usually used to execute commands gen-
	     erated  as	 the  result  of command or variable substitution. See
	     tset(1B) for an example of	how to use eval.

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

       exit [(expr)]
	     The calling shell or shell	script exits, either with the value of
	     the status	variable or with the value specified by	the expression
	     expr.

       fg [%job	]
	     Bring the current or specified job	into the foreground.

       foreach var (wordlist)

	  ...

       end   The variable var is successively set to each member of  wordlist.
	     The  sequence  of	commands between this command and the matching
	     end is executed for each new value	of var.	Both foreach  and  end
	     must appear alone on separate lines.

	     The built-in command continue may be used to terminate the	execu-
	     tion of the current iteration of the loop and the	built-in  com-
	     mand break	may be used to terminate execution of the foreach com-
	     mand. When	this command is	read from the terminal,	 the  loop  is
	     read  once	prompting with ? before	any statements in the loop are
	     executed.

       glob wordlist
	     Perform filename expansion	on wordlist. Like echo,	but no	\  es-
	     capes  are	 recognized. Words are delimited by NULL characters in
	     the output.

       goto label
	     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.

       hashstat
	     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  cd-
	     path variable.

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

	     -r	   Reverse the order of	 printout  to  be  most	 recent	 first
		   rather than oldest first.

	     -h	   Display  the	 history list without leading numbers. This is
		   used	to produce files suitable for sourcing	using  the  -h
		   option to source.

       if (expr	)command
	     If	the specified expression evaluates to true, the	single command
	     with arguments is executed. Variable substitution on command hap-
	     pens  early, at the same time it does for the rest	of the if com-
	     mand. command must	be a simple command, not a pipeline, a command
	     list, or a	parenthesized command list. Note:  I/O redirection oc-
	     curs even if expr is false, when command is not executed (this is
	     a bug).

       if (expr) then

       ...

       else if ( expr2)	then

       ...

       else

       ...

	endif
	     If	expr is	true, commands up to the first else are	executed. Oth-
	     erwise, 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.

       jobs [-l]
	     List the active jobs under	job control.

	     - l   List	process	IDs, in	addition to the	normal information.

       kill [ -sig ] [ pid ] [ %job ] ...

       kill -l
	     Send the TERM (terminate) signal, by default, or the signal spec-
	     ified,  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) sig-
	     nal as well.

	     -l	   List	the signal names that can be sent.

       limit [-h] [resource [max-use ] ]
	     Limit the consumption by the current process or  any  process  it
	     spawns,  each not to exceed max-use on the	specified resource. If
	     max-use is	omitted, print the current limit; if resource is omit-
	     ted,  display  all	 limits. (Run the sysdef(1M) command to	obtain
	     the maximum possible limits for your system.  The values reported
	     are  in  hexadecimal,  but	can be translated into decimal numbers
	     using the bc(1) command).

	     -h	   Use hard limits instead of the current limits. Hard	limits
		   impose  a ceiling on	the values of the current limits. Only
		   the privileged user may raise the hard limits.

       resource	is one of:

	     cputime
		   Maximum CPU seconds per process.

	     filesize
		   Largest single file allowed;	limited	to  the	 size  of  the
		   filesystem. (see df(1M)).

	     datasize (heapsize)
		   Maximum  data  size (including stack) for the process. This
		   is the size of your virtual memory See swap(1M).

	     stacksize
		   Maximum stack size for the process. See swap(1M).

	     coredumpsize
		   Maximum size	of a core dump (file).	This  limited  to  the
		   size	of the filesystem.

	     descriptors
		   Maximum number of file descriptors. Run sysdef().

	     memorysize
		   Maximum size	of virtual memory.

       max-use is a number, with an optional scaling factor, as	follows:

	     nh	   Hours (for cputime).

	     nk	   n kilobytes.	This is	the default for	all but	cputime.

	     nm	   n megabytes or minutes (for cputime).

	     mm:ss Minutes and seconds (for cputime).

	     Example  of  limit:   to  limit the size of a core	file dump to 0
	     Megabytes,	type the following:

		    limit coredumpsize 0M

       login [username|	-p ]
	     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	   Preserve the	current	environment (variables).

       logout
	     Terminate a login shell.

       nice [+n	|-n ] [command ]
	     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,  respec-
	     tively.

	     +n	   Increment the process priority value	by n.

	     -n	   Decrement by	n. This	argument can be	used only by the priv-
		   ileged user.

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

       notify [%job] ...
	     Notify the	user asynchronously when the status of the current job
	     or	specified jobs changes.

       onintr [-| label]
	     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 la-
	     bel when an interrupt is received or a child  process  terminates
	     because it	was interrupted.

       popd [+n	]
	     Pop the directory stack and cd to the new top directory. The ele-
	     ments of the directory stack are numbered from 0 starting at  the
	     top.

	     +n	   Discard the n'th entry in the stack.

       pushd [+n |dir]
	     Push a directory onto the directory stack.	With no	arguments, ex-
	     change the	top two	elements.

	     +n	   Rotate the n'th entry to the	top of the stack and cd	to it.

	     dir   Push	the current  working  directory	 onto  the  stack  and
		   change to dir.

       rehash
	     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 count command
	     Repeat  command  count  times. command is subject to the same re-
	     strictions	as with	the one-line if	statement.

       set [var	[= value ] ]

       set var[n ] = word
	     With no arguments,	set displays the values	 of  all  shell	 vari-
	     ables.  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 as-
	     signs value to var, where value is	one of:

	     word  A single word (or quoted string).

	     (wordlist)
		   A space-separated list of words enclosed in parentheses.

	     Values are	command	and filename expanded before  being  assigned.
	     The  form set var[n] = word replaces the n'th word	in a multiword
	     value with	word.

       setenv [VAR  [word ] ]
	     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	 vari-
	     ables  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 vari-
	     able from the csh variable	cwd whenever the latter	changes.

	     The environment variables LC_CTYPE, LC_MESSAGES, LC_TIME, LC_COL-
	     LATE,  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
		   Determines how csh handles characters. When LC_CTYPE	is set
		   to a	valid value, csh can display and handle	text and file-
		   names containing valid characters for that locale.

	     LC_MESSAGES
		   Determines how diagnostic and informative messages are pre-
		   sented. This	includes the language and style	 of  the  mes-
		   sages  and the correct form of affirmative and negative re-
		   sponses.  In	the "C"	locale,	the messages are presented  in
		   the	default	 form  found  in  the  program itself (in most
		   cases, U.S./English).

	     LC_NUMERIC
		   Determines the value	of the radix character (decimal	 point
		   (".")  in  the  "C"	locale)	 and thousand separator	(empty
		   string ("") in the "C" locale).

       shift [variable ]
	     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.

       source [-h] name
	     Reads commands from name. source commands may be nested,  but  if
	     they are nested too deeply	the shell may run out of file descrip-
	     tors. An error in a sourced file  at  any	level  terminates  all
	     nested source commands.

	     -h	   Place commands from the file	name on	the history list with-
		   out executing them.

       stop %jobid ...
	     Stop the current or specified background job.

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

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

       switch (string)

       case label:

	...

       breaksw

       ...

       default:

       ...

       breaksw

       endsw Each label	is successively	matched, against the specified string,
	     which  is first command and filename expanded. The	file metachar-
	     acters *, ? and [...] may 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 be-
	     ginning 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.

       time [command ]
	     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

	     (See below	the "Environment Variables and Predefined Shell	 Vari-
	     ables" sub-section	on the time variable.)

       umask [value ]
	     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.

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

       unhash
	     Disable the internal hash tables for the path  and	 cdpath	 vari-
	     ables.

       unlimit [-h] [resource ]
	     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  corresponding hard limits. Only the privileged user
		   may do this.

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

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

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

       while (expr)

       ...

       end   While expr	is true	(evaluates to nonzero),	 repeat	 commands  be-
	     tween  the	 while	and the	matching end statement.	break and con-
	     tinue may 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 ques-
	     tion-mark	until the end command is entered and then performs the
	     commands in the loop.

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

       @ [var =expr]

       @ [var[ n]=expr]
	     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  op-
	     tional.  Spaces  are, however, mandatory in separating components
	     of	expr that would	otherwise be single words.

	     Special postfix operators,	++  and	 --,  increment	 or  decrement
	     name, respectively.

   Environment Variables and Predefined	Shell Variables
       Unlike  the  Bourne  shell, the C shell maintains a distinction between
       environment variables, which are	automatically exported to processes it
       invokes,	 and  shell  variables,	which are not. Both types of variables
       are treated similarly under variable substitution. The shell  sets  the
       variables  argv,	 cwd,  home, path, prompt, shell, and status upon ini-
       tialization. The	shell copies the environment variable  USER  into  the
       shell  variable	user,  TERM  into term,	and HOME into home, and	copies
       each back into the respective environment variable whenever  the	 shell
       variables are reset. PATH and path are similarly	handled. You need only
       set path	once in	the .cshrc or .login file.  The	 environment  variable
       PWD  is	set  from cwd whenever the latter changes. The following shell
       variables have predefined meanings:

       argv  Argument list. Contains the list of command line  arguments  sup-
	     plied  to	the current invocation of the shell. This variable de-
	     termines the value	of the positional parameters $1,  $2,  and  so
	     on.

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

       cwd   The full pathname of the current directory.

       echo  Echo commands (after substitutions) just before execution.

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

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

	     EOT   Print a list	of all filenames that start with the preceding
		   string.

	     ESC   Replace  the	 preceding string with the longest unambiguous
		   extension.

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

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

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

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

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

       mail  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  in-
	     terval in seconds (default	5 minutes).

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

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

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

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

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

       path  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 may
	     override this initial search path upon csh	start-up by setting it
	     in	.cshrc or .login (for login shells only). If path becomes  un-
	     set,  only	 full  pathnames  will execute.	An interactive C shell
	     will normally hash	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.

       prompt
	     The string	an interactive C shell	prompts	 with.	Noninteractive
	     shells  leave  the	 prompt	variable unset.	Aliases	and other com-
	     mands 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	privi-
	     leged user.

	     The setting of $prompt has	three meanings:

	     $prompt not set
		   non-interactive shell, test $?prompt.

	     $prompt set but ==	""
		   .cshrc called by the	which(1) command.

	     $prompt set and !=	""
		   normal interactive shell.

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

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

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

       time  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  re-
	     sources  to  report on. A tag is a	percent	sign (%) followed by a
	     single upper-case letter (unrecognized tags print as text):

	     %D	   Average amount of unshared data space used in Kilobytes.

	     %E	   Elapsed (wallclock) time for	the command.

	     %F	   Page	faults.

	     %I	   Number of block input operations.

	     %K	   Average amount of unshared stack space used in Kilobytes.

	     %M	   Maximum real	memory used during execution of	the process.

	     %O	   Number of block output operations.

	     %P	   Total CPU time -- U (user) plus S (system) -- as a percent-
		   age of E (elapsed) time.

	     %S	   Number of seconds of	CPU time consumed by the kernel	on be-
		   half	of the user's process.

	     %U	   Number of  seconds  of  CPU	time  devoted  to  the	user's
		   process.

	     %W	   Number of swaps.

	     %X	   Average amount of shared memory used	in Kilobytes.

	     The  default summary display outputs from the %U, %S, %E, %P, %X,
	     %D, %I, %O, %F, and %W tags, in that order.

       verbose
	     Display each command after	history	substitution takes place.

   Large File Behavior
       See largefile(5)	for the	description of the behavior of	csh  when  en-
       countering files	greater	than or	equal to 2 Gbyte ( 2**31 bytes).

FILES
       ~/.cshrc
	     Read at beginning of execution by each shell.

       ~/.login
	     Read by login shells after	.cshrc at login.

       ~/.logout
	     Read by login shells at logout.

       ~/.history
	     Saved history for use at next login.

       /usr/bin/sh
	     The Bourne	shell, for shell scripts not starting with a `#'.

       /tmp/sh*
	     Temporary file for	`<<'.

       /etc/passwd
	     Source of home directories	for `~name'.

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+

SEE ALSO
       bc(1),	 echo(1),    login(1),	  ls(1),    more(1),   ps(1),	sh(1),
       shell_builtins(1), tset(1B), which(1), df(1M),  swap(1M),   sysdef(1M),
       access(2),  exec(2),  fork(2), pipe(2), a.out(4), environ(4), ascii(5),
       attributes(5), environ(5), largefile(5),	termio(7I)

DIAGNOSTICS
       You have	stopped	jobs.
	     You attempted to exit the C shell with  stopped  jobs  under  job
	     control.	An immediate second attempt to exit will succeed, ter-
	     minating the stopped jobs.

WARNINGS
       The use of setuid shell scripts is strongly discouraged.

NOTES
       Words can be no longer than 1024	 bytes.	 The  system  limits  argument
       lists to	1,048,576 bytes. However, the maximum number of	arguments to a
       command for which filename expansion applies is 1706. Command substitu-
       tions may expand	to no more characters than are allowed in the argument
       list. To	detect looping,	the shell restricts the	number of  alias  sub-
       stitutions on a single line to 20.

       When a command is restarted from	a stop,	the shell prints the directory
       it started in if	this is	different from the current directory; this can
       be  misleading (that is,	wrong) as the job may have changed directories
       internally.

       Shell built-in functions	are  not  stoppable/restartable.  Command  se-
       quences	of  the	 form  a  ; b ;	c are also not handled gracefully when
       stopping	is attempted. If you suspend b,	the shell  never  executes  c.
       This  is	 especially noticeable if the expansion	results	from an	alias.
       It can be avoided by placing the	sequence in parentheses	 to  force  it
       into a subshell.

       Control	over terminal output after processes are started is primitive;
       use the Sun Window system if you	need better output control.

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

       Control	structures  should  be	parsed rather than being recognized as
       built-in	commands. This would allow control commands to be placed  any-
       where, to be combined with |, and to be used with & and ; metasyntax.

       It  should  be possible to use the : modifiers on the output of command
       substitutions. There are	two problems with : modifier usage on variable
       substitutions:  not  all	 of  the modifiers are available, and only one
       modifier	per substitution is allowed.

       The g (global) flag in history substitutions applies only to the	 first
       match  in  each	word, rather than all matches in all words. The	common
       text editors consistently do the	latter when given the g	flag in	a sub-
       stitution command.

       Quoting	conventions  are confusing. Overriding the escape character to
       force variable substitutions within double quotes  is  counterintuitive
       and inconsistent	with the Bourne	shell.

       Symbolic	links can fool the shell. Setting the hardpaths	variable alle-
       viates this.

       It is up	to the user to manually	remove all duplicate pathnames accrued
       from using built-in commands as

       set path	= pathnames

       or

       setenv PATH = pathnames

       more  than  once.  These	often occur because a shell script or a	.cshrc
       file does something like

       `set path=(/usr/local /usr/hosts	$path)'

       to ensure that the named	directories are	in the pathname	list.

       The only	way to direct the standard output  and	standard  error	 sepa-
       rately is by invoking a subshell, as follows:

       command > outfile) >& errorfile

       Although	 robust	 enough	 for general use, adventures into the esoteric
       periphery of the	C shell	may reveal unexpected quirks.

       If you start csh	as a login shell and you do not	have a .login in  your
       home directory, then the	csh reads in the /etc/.login.

       When  the shell executes	a shell	script that attempts to	execute	a non-
       existent	command	interpreter, the shell returns an erroneous diagnostic
       message that the	shell script file does not exist.

BUGS
       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

SunOS 5.9			  23 May 1997				csh(1)

NAME | SYNOPSIS | DESCRIPTION | OPTIONS | USAGE | FILES | ATTRIBUTES | SEE ALSO | DIAGNOSTICS | WARNINGS | NOTES | BUGS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=csh&sektion=1&manpath=SunOS+5.9>

home | help