*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->IRIX man pages -> csh (1)              


csh(1)									csh(1)

NAME    [Toc]    [Back]

     csh - shell command interpreter with a C-like syntax

SYNOPSIS    [Toc]    [Back]

     csh [ -bcefinstvVxX ] [ argument ... ]

DESCRIPTION    [Toc]    [Back]

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

   Initialization and Termination    [Toc]    [Back]
     When first	started, the C shell normally performs commands	from the
     .cshrc file in your home directory, provided that it is readable and you
     either own	it or your real	group ID matches its group ID.	If the shell
     is	invoked	with a name that starts	with `-', as when started by login(1),
     the shell runs as a login shell.  In this case, before executing the
     commands from the .cshrc file, the	shell executes the commands from the
     following files in	the order specified:  /etc/cshrc, /etc/.login and
     /etc/csh.cshrc.  These files can be used to provide system-wide settings
     for all csh users.	 After executing commands from the .cshrc file,	a
     login shell executes commands from	the .login file	in your	home
     directory;	the same permission checks as those for	.cshrc are applied to
     this file.	 Typically, the	.login file contains commands to specify the
     terminal type and environment.  Please note that csh can run as a login
     shell if it is invoked upon startup of a window shell such	as xwsh(1G).
     This is so	any terminal type information that might be contained in the
     .login file(s) can	be made	known to the window shell.

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

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

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

									Page 1

csh(1)									csh(1)

     The following options are available:

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

     -c	  Read commands	from the first filename	argument (which	must be
	  present).  Remaining arguments are placed in argv, the argument-list

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

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

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

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

     -s	  Take commands	from the standard input.

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

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

     -V	  Set verbose before reading .cshrc.

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

     -X	  Set echo before reading .cshrc.

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

	  #! /bin/csh -f

     which causes the script to	be executed by /bin/csh	even if	invoked	by a
     user running a shell other	than csh and inhibits processing of the	.cshrc
     file to prevent interference from aliases defined by the invoking user.

									Page 2

csh(1)									csh(1)

USAGE    [Toc]    [Back]

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

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

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

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

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

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

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

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

									Page 3

csh(1)									csh(1)

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

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

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

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

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

   Event Designators
     An	event designator is a reference	to a command-line entry	in the history

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

     !!	       Refer to	the previous command.  By itself, this substitution
	       repeats the previous command.

     !n	       Refer to	command	line n .

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

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

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

     !{...}    Insulate	a history reference from adjacent characters (if

									Page 4

csh(1)									csh(1)

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

     #	  The entire command line typed	so far.
     0	  The first input word (command).
     n	  The n'th argument.
     ^	  The first argument, that is, 1.
     $	  The last argument.
     %	  The word matched by (the most	recent)	?s search.
     x<b>-y  A range of words; -y abbreviates 0-y.
     *	  All the arguments, or	a null value if	there is just one word in the
     x<b>*	  Abbreviates x<b>-$.
     x<b>-	  Like x* but omitting word $.

     After the optional	word designator, you can add a sequence	of one or more
     of	the following modifiers, each preceded by a :.

     h	  Remove a trailing pathname component,	leaving	the head.
     r	  Remove a trailing suffix of the form `.xxx', leaving the basename.
     e	  Remove all but the suffix.
	  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

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

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

									Page 5

csh(1)									csh(1)

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

   Quick Substitution
     ^l<b>^r[^]   This is equivalent to the history substitution:	!:s^l<b>^r[^].

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

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

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

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

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

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

     <	       Redirect	the standard input.

     <<word    Read the	standard input,	up to a	line that is identical with
	       word, and place the resulting lines in a	temporary file.
	       Unless word is escaped or quoted, variable and command
	       substitutions are performed on these lines.  Then, invoke the
	       pipeline	with the temporary file	as its standard	input.	word
	       is not subjected	to variable, filename, or command
	       substitution, and each line is compared to it before any
	       substitutions are performed by the shell.

     >	 >!   >&   >&!
	       Redirect	the standard output to a file.	If the file does not
	       exist, it is created.  If it does exist,	it is overwritten; its
	       previous	contents are lost.

									Page 6

csh(1)									csh(1)

	       When set, the variable noclobber	prevents destruction of
	       existing	files.	It also	prevents redirection to	terminals and
	       /dev/null, unless one of	the ! forms is used.  The & forms
	       redirect	both standard output and the standard error
	       (diagnostic output) to the file.

     >>	  >>&	>>!   >>&!
	       Append the standard output.  Like >, but	places output at the
	       end of the file rather than overwriting it.  If noclobber is
	       set, it is an error for the file	not to exist, unless one of
	       the ! forms is used.  The & forms append	both the standard
	       error and standard output to the	file.

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

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

     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

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

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

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

     Command and filename substitution is subsequently applied to the words
     that result from the variable substitution, except	when suppressed	by
     double-quotes, when noglob	is set (suppressing filename substitution), or

									Page 7

csh(1)									csh(1)

     when the reference	is quoted with the :q modifier.	 Within	double-quotes,
     a reference is expanded to	form (a	portion	of) a quoted string; multiword
     values are	expanded to a string with embedded space characters.  When the
     :q	modifier is applied to the reference, it is expanded to	a list of
     space-separated words, each of which is quoted to prevent subsequent
     command or	filename substitutions.

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

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

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

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

     $0		    This substitutes the name of the file from which command
		    input is being read.  An error occurs if the name is not

     ${n<b>}	    Equivalent to $argv[n<b>].

     $*		    Equivalent to $argv[*].

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

     The following references cannot be	modified with :	modifiers.

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

									Page 8

csh(1)									csh(1)

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

     $$	       Substitute the process number of	the (parent) shell.

     $<	       Substitutes a line from the standard input, with	no further
	       interpretation thereafter.  It can be used to read from the
	       keyboard	in a C shell script.

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

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

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

     *		    Match any (zero or more) characters.

     ?		    Match any single character.

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

     { str<b>, str<b>, ... }
		    Expand to each string (or filename-matching	pattern) in
		    the	comma-separated	list.  Unlike the pattern-matching
		    expressions	above, the expansion of	this construct is not
		    sorted.  For instance, {b,a} expands to `b'	`a', (not `a'
		    `b').  As special cases, the characters { and }, along
		    with the string {},	are passed undisturbed.

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

									Page 9

csh(1)									csh(1)

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

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

     Null or missing values are	considered 0.  The result of all expressions
     are strings, which	can represent decimal numbers.

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

     (...)		 grouping
     ~			 one's complement
     !			 logical negation
     *	 /   %		 multiplication, division, remainder (These are	right
			 associative, which can	lead to	unexpected results.
			 Group combinations explicitly with parentheses.)
     +	 -		 addition, subtraction (also right associative)
     <<	  >>		 bitwise shift left, bitwise shift right
     <	 >   <=	  >=	 less than, greater than, less than or equal to,
			 greater than or equal to
     ==	  !=   =~   !~	 equal to, not equal to, filename-substitution pattern
			 match (described below), filename-substitution
			 pattern mismatch
     &			 bitwise AND
     ^			 bitwise XOR (exclusive	or)
     |			 bitwise inclusive OR
     &&			 logical AND
     ||			 logical OR

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

     Also available are	file inquiries:

     -r	file   Return true, or 1 if the	user has read access.  Otherwise it
	       returns false, or 0.
     -w	file   True if the user	has write access.
     -x	file   True if the user	has execute permission (or search permission
	       on a directory).

								       Page 10

csh(1)									csh(1)

     -e	file   True if file exists.
     -o	file   True if the user	owns file.
     -z	file   True if file is of zero length (empty).
     -f	file   True if file is a plain file.
     -d	file   True if file is a directory.
     -l	file   True if file is a symbolic link.
     -c	file   True if file is a character special file.
     -b	file   True if file is a block special file.
     -p	file   True if file is a named pipe (fifo).
     -u	file   True if file has	the set-user-ID	permission bit set (see
     -g	file   True if file has	the set-group-ID permission bit	set (see
     -k	file   True if file has	the sticky bit set (see	chmod(1)).
     -s	file   True if file has	size strictly greater than zero.
     -t	file   True if file is an open file descriptor for a terminal device.

     If	file does not exist or is inaccessible,	then all inquiries return

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

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

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

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

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

   Command Execution    [Toc]    [Back]
     If	the command is a C shell built-in, the shell executes it directly.
     Otherwise,	the shell searches for a file by that name with	execute
     access.  If the command-name contains a /,	the shell takes	it as a
     pathname, and searches for	it.  If	the command-name does not contain a /,
     the shell attempts	to resolve it to a pathname, searching each directory
     in	the path variable for the command.  To speed the search, the shell
     uses its hash table (see the rehash built-in) to eliminate	directories

								       Page 11

csh(1)									csh(1)

     that have no applicable files.  This hashing can be disabled with the -c
     or	-t, options, or	the unhash built-in.

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

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

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

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

     o	Otherwise, a standard (Bourne) shell is	invoked.

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

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

	  [1] 1234

								       Page 12

csh(1)									csh(1)

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

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

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

     %	 %+   %%    The	current	job.

     %-		    The	previous job.

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

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

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

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

   Built-In Commands    [Toc]    [Back]
     Built-in commands are executed within the C shell.	 If a built-in command
     occurs as any component of	a pipeline except the last, it is executed in
     a subshell.

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

     alias [ name [ def	] ]
		    Assign def to the alias name.  def is a list of words that
		    can	contain	escaped	history-substitution metasyntax.  name
		    is not allowed to be alias or unalias.  If def is omitted,
		    the	alias name is displayed	along with its current
		    definition.	 If both name and def are omitted, all aliases
		    are	displayed.

								       Page 13

csh(1)									csh(1)

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

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

     breaksw	    Break from a switch, resuming after	the endsw.

     case label<b>:    A label in a switch	statement.

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

     continue	    Continue execution of the nearest enclosing	while or

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

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

     echo [ -n ] list
		    The	words in list are written to the shell's standard
		    output, separated by space characters.  The	output is
		    terminated with a newline unless the -n option or the \c
		    escape is specified.  The following	C-like escape
		    sequences are available:

		    \b	 backspace
		    \c	 print line without newline
		    \f	 formfeed
		    \n	 newline
		    \r	 carriage return
		    \t	 tab
		    \\	 backslash
		    \0n	 the 8-bit character whose code	is the 1-, 2- or 3-
			 digit octal number n.	Note that \n (no leading zero)
			 is accepted for backwards compatibility with older
			 IRIX cshs.  This can cause unexpected results in
			 older scripts if the character	immediately trailing

								       Page 14

csh(1)									csh(1)

			 three digits is also numeric.

     eval  argument ...
		    Reads the arguments	as input to the	shell, and executes
		    the	resulting command(s).  This is usually used to execute
		    commands generated as the result of	command	or variable
		    substitution, since	parsing	occurs before these
		    substitutions.  See	tset(1)	for an example of how to use

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

     exit [ (expr<b>) ]
		    The	shell exits, either with the value of the STATUS
		    variable, or with the value	specified by the expression

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

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

		    The	built-in command continue can be used to continue the
		    loop prematurely and the built-in command break to
		    terminate it prematurely.  When this command is read from
		    the	terminal, the loop is read up once prompting with ?
		    before any statements in the loop are executed.

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

     goto label	    The	specified label	is filename and	command	expanded to
		    yield a label.  The	shell rewinds its input	as much	as
		    possible and searches for a	line of	the form label<b>:
		    possibly preceded by space or tab characters.  Execution
		    continues after the	indicated line.	 It is an error	to
		    jump to a label that occurs	between	a while	or for builtin,
	and its	corresponding end.

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

								       Page 15

csh(1)									csh(1)

		    -r	 Reverse the order of printout to be most recent first
			 rather	than oldest first.
		    -h	 Display the history list without leading numbers.
			 This is used to produce files suitable	for sourcing
			 using the -h option to	source.

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

     if	(expr<b>) then
     else if (expr2<b>) then
     endif	    If expr"" is true, commands	up to the first	

 Similar pages
Name OS Title
csh HP-UX a shell (command interpreter) with C-like syntax
suspend OpenBSD a shell (command interpreter) with C-like syntax
unlimit OpenBSD a shell (command interpreter) with C-like syntax
dirs OpenBSD a shell (command interpreter) with C-like syntax
csh OpenBSD a shell (command interpreter) with C-like syntax
foreach OpenBSD a shell (command interpreter) with C-like syntax
bg OpenBSD a shell (command interpreter) with C-like syntax
alias OpenBSD a shell (command interpreter) with C-like syntax
pushd OpenBSD a shell (command interpreter) with C-like syntax
source OpenBSD a shell (command interpreter) with C-like syntax
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service