csh man page on SmartOS

Man page or keyword search:  
man Server   16655 pages
apropos Keyword Search (all sections)
Output format
SmartOS logo
[printable version]

CSH(1)									CSH(1)

       csh - shell command interpreter with a C-like syntax

       csh [-bcefinstvVxX] [argument]...

       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
       environment. (For an explanation of file interpreters, see Command Exe‐
       cution 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. Finally, the shell executes each com‐
       mand 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.

       The following options are supported:

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

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

	     Exits if a command terminates abnormally or yields a nonzero exit

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

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

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

	     Takes commands from the standard input.

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

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

	     Sets verbose before reading .cshrc.

	     Echo. Sets the echo variable. Echoes commands after all substitu‐
	     tions and just before execution.

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

   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 Control-d), the shell	 lists	all  filenames	that  match.  It  then
       prompts	once  again, supplying the incomplete command line typed in so

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

       The terminal bell signals errors or multiple matches. This bell	signal
       can  be inhibited by setting the variable nobeep. You can exclude files
       with certain suffixes by listing those suffixes in  the	variable  fig‐
       nore.  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.  Metachar‐
       acters 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
       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	 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 occurs 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 char‐
	   acter, tab, newline, = or (.


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


	   Refer to command line n.


	   Refer to the current command line minus n.


	   Refer to the most recent command starting with str.


	   Refer to the most recent command containing str.

       !?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 append
	   additional to that referenced command.


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


	   To re-execute a specific previous command AND make such a substitu‐
	   tion, say, re-executing command #6,


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

		 The first input word (command).

		 The n'th argument.

		 The first argument, that is, 1.

		 The last argument.

		 The word matched by the ?s search.

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

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

		 Abbreviates x−$.

		 Like x* but omitting word $.

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

		 Remove a trailing pathname component, leaving the head.

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

		 Remove all but the suffix, leaving the Extension.

		 Substitute r for l.

		 Remove all leading pathname components, leaving the tail.

		 Repeat the previous substitution.

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

		 Print the new command but do not execute it.

		 Quote the substituted words,escaping further substitutions.

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

       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
		This is equivalent to the history substitution:


       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 defini‐
       tion 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  defini‐
       tion,  to be replaced with actual command line arguments when the alias
       is used. If no history substitution is called for, the arguments remain

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

		      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 com‐
		      pared  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 over‐
		      written; its previous contents are lost.

		      When set, the variable noclobber prevents destruction of
		      existing	files.	It also prevents redirection to termi‐
		      nals and /dev/null, unless one of the ! forms  is	 used.
		      The  & forms redirect both standard output and the stan‐
		      dard 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 128 letters and
       digits, and starts with a letter. An underscore	(_)  is	 considered  a
       letter).	 A  variable's value is a space-separated list of zero or more
       words. If the shell supports a variable name upto  128  characters  the
       variable	 SUNW_VARLEN is defined. If a variable name of up to 128 char‐
       acters is not supported, then an older version of the  shell  is	 being
       used, and the shell variable name length has a maximum length of 20.

       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
       input-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‐

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

			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

			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 aster‐
			isk. Words are indexed starting from 1; a `*'  selects
			all  words.  If the first number of a range is omitted
			(as with $argv[−2]), it defaults to  1.	 If  the  last
			number	of  a range is omitted (as with $argv[1−]), it
			defaults to $#var (the word count). It is not an error
			for  a	range  to  be  empty if the second argument is
			omitted (or within range).

			These give the number of words in the variable.

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

			Equivalent to $argv[n].

			Equivalent to $argv[*].

       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 can not be modified with : modifiers.

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

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

		  Substitutes the process number of the (parent) shell.

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

   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;
       expansion 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 separated
			       by a dash (−), and includes all the  characters
			       in between in the ASCII collating sequence (see

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

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

       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 path‐
       name 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 can represent decimal numbers.

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


			  one's complement

			  logical negation

       * / %
			  multiplication, division, remainder. These are right
			  associative,	which  can lead to unexpected results.
			  Combinations	should	be  grouped  explicitly	  with

       + −
			  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  pat‐
			  tern	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 pattern-
       matching between strings is all that is required.

       Also available are file inquiries:

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

		      True if the user has write access.

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

		      True if filename exists.

		      True if the user owns filename.

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

		      True if filename is a plain file.

		      True if filename is a directory.

       If filename does not exist  or  is  inaccessible,  then	all  inquiries
       return 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: Con‐
		     versely,  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 expres‐

   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
       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 succeeds on nonseekable inputs.)

   Command Execution
       If the command is a C shell built-in command,  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  command)  to
       eliminate  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
       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 argu‐

       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
       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  and  the  execve()	 call  fails  (see  exec(2)). 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

	   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 Control-z). When a command or com‐
       mand  sequence  (semicolon separated list) is started in the background
       using the & metacharacter, the shell displays a line with the job  num‐
       ber 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

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

       % %+ %%
		   The current job.

		   The previous job.

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

		   Specify  the	 job  for which the command line uniquely con‐
		   tains 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.

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

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

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

				 Break	from  a	 switch,  resuming  after  the

       case label:
				 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	direc‐
				 tory named by that value.

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

				 Labels the default case in  a	switch	state‐
				 ment.	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  cur‐
				 rent directory. With the -l argument, produce
				 an unabbreviated printout; use of the ~ nota‐
				 tion is suppressed.

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

       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 substitu‐
				 tion. 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

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

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

       glob wordlist

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


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


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

       history [-hr] [n]

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

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

		 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 occurs
	   even if expr is false, when command is  not	executed  (this	 is  a

       if (expr) then
       else if (expr2) then

	   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.

		 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 speci‐
	   fied, to the specified process ID, the job indicated, or  the  cur‐
	   rent	 job.  Signals are either given by number or by name. There is
	   no default. Typing kill does not send a signal to the current  job.
	   If  the signal being sent is TERM (terminate) or HUP (hangup), then
	   the job or process is sent a CONT (continue) signal as well.

		 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. The
	   string unlimited requests  that  the	 current  limit,  if  any,  be
	   removed.  If	 max-use  is  omitted,	print  the  current  limit. If
	   resource is omitted, display all limits. Run the sysdef(1M) command
	   to  display	maximum	 limits	 for  certain resources in your system
	   (although it does not report stack size). The values	 reported  are
	   in  hexadecimal,  but  can be translated into decimal numbers using
	   the bc(1) command.

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

	   resource is one of:

				  Maximum CPU seconds per process.

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

				  Maximum  stack  size	for  the  process. The
				  default stack size is 2^64  bytes.  You  can
				  use limit(1) to change this default within a

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

				  Maximum number of file descriptors. Run sys‐

				  Maximum size of virtual memory.

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

		    Hours (for cputime).

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

		    n megabytes or minutes (for cputime).

		    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.

		 Preserve the current environment (variables).


	   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, respectively.

		 Increment the process priority value by n.

		 Decrement  by n. This argument can be used only by the privi‐
		 leged user.

       nohup [command ]

	   Run command with HUPs  ignored.  With  no  arguments,  ignore  HUPs
	   throughout the remainder of a script. When given, command is always
	   run in a subshell, and the restrictions placed on commands in  sim‐
	   ple	if  statements apply. All processes detached with & are effec‐
	   tively 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	inter‐
	   rupts.  With a label argument, the shell executes a goto label 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

		 Discard the n'th entry in the stack.

       pushd [+n |dir]

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

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

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


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

       repeat count command

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

       set [var [= value ] ]
       set var[n] = word

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

			 A single word (or quoted string).

			 A space-separated list of words enclosed in parenthe‐

	   Values are command and filename expanded before being assigned. The
	   form	 setvar[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	variables  are
	   normally given upper-case names.) With both VAR and word arguments,
	   setenv sets the environment variable NAME to the value word,	 which
	   must be either a single word or a quoted string.  The most commonly
	   used environment variables, USER, TERM, and PATH, are automatically
	   imported  to	 and  exported	from the csh variables user, term, and
	   path. There is no need to use setenv for these.  In	addition,  the
	   shell  sets	the PWD environment variable from the csh variable cwd
	   whenever the latter changes.

	   The environment variables LC_CTYPE, LC_MESSAGES,  LC_TIME,  LC_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.

			  Determines how csh handles characters. When LC_CTYPE
			  is set to a valid value, csh can display and	handle
			  text	and  filenames containing valid characters for
			  that locale.

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

			  Determines the value of the radix character, decimal
			  point, (.) in the "C" locale) and  thousand  separa‐
			  tor, 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 can be nested, but if
	   they are nested too deeply the shell can run out of	file  descrip‐
	   tors. An error in a sourced file at any level terminates all nested
	   source commands.

		 Place commands from the file name on the history list without
		 executing them.

       stop %jobid ...

	   Stop the current or specified background job.

       stop pid ...

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


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

       switch (string)
       case label:

	   Each	 label	is successively matched, against the specified string,
	   which is first command and filename expanded. The file  metacharac‐
	   ters *, ? and [...] can be used in the case labels, which are vari‐
	   able expanded. If none of the labels match before a "default" label
	   is  found,  execution  begins  after	 the  default label. Each case
	   statement and the default statement must appear at the beginning of
	   a  line.  The  command breaksw continues execution after the endsw.
	   Otherwise control falls through subsequent case and default	state‐
	   ments  as with C. If no label matches and there is no default, exe‐
	   cution 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 the Environment Variables and Predefined Shell Variables  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 *'.


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

       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.

		 Remove corresponding hard limits. Only	 the  privileged  user
		 can do this.

       unset pattern

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

       unsetenv variable

	   Remove variable from the environment. As with unset, pattern match‐
	   ing is not performed.


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

       while (expr)

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

       % [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 optional.
	   Spaces  are,	 however,  mandatory  in separating components of expr
	   that would otherwise be single words.

	   Special postfix operators, ++ and −−, increment or decrement	 name,

   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:

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

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

		    The full pathname of the current directory.

		    Echo commands (after substitutions) just before execution.

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

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

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

			   Replace the preceding string with the longest unam‐
			   biguous extension.

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

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

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

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

		    If set, the shell ignores EOF from	terminals.  This  pro‐
		    tects  against  accidentally killing a C shell by typing a

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

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

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

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

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

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

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

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

		    The setting of $prompt has three meanings:

		    $prompt not set
					     non-interactive	shell,	  test

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

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

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

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

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

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

			  Average amount of unshared data space used in	 Kilo‐

			  Elapsed (wallclock) time for the command.

			  Page faults.

			  Number of block input operations.

			  Average amount of unshared stack space used in Kilo‐

			  Maximum real memory used  during  execution  of  the

			  Number of block output operations.

			  Total	 CPU  time  —  U (user) plus S (system) — as a
			  percentage of E (elapsed) time.

			  Number of seconds of CPU time consumed by the kernel
			  on behalf of the user's process.

			  Number  of seconds of CPU time devoted to the user's

			  Number of swaps.

			  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.

		    Display  each  command  after  history  substitution takes

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

		      Read at beginning of execution by each shell.

		      Read by login shells after .cshrc at login.

		      Read by login shells at logout.

		      Saved history for use at next login.

		      The  Bourne shell, for shell scripts not starting with a

		      Temporary file for `<<'.

		      Source of home directories for `~name'.

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

       │CSI	       │ Enabled	 │

       bc(1),  echo(1),	 limit(1),   login(1),	 ls(1),	  more(1),   pfcsh(1),
       pfexec(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),
       ascii(5), attributes(5), environ(5), largefile(5), termio(7I)

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

       The use of setuid shell scripts is strongly discouraged.

       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 can 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 might have changed directo‐
       ries internally.

       Shell  built-in	functions  are	not   stoppable/restartable.   Command
       sequences  of the form a b c are also not handled gracefully when stop‐
       ping 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

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

       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


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

       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

				 Jul 27, 2007				CSH(1)

List of man pages available for SmartOS

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net