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

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



NAME    [Toc]    [Back]

       tcsh - C shell with file name completion and command line editing

SYNOPSIS    [Toc]    [Back]

       tcsh [-bcdefFimnqstvVxX] [-Dname[=value]] [arg ...]
       tcsh -l

DESCRIPTION    [Toc]    [Back]

       tcsh  is  an enhanced but completely compatible version of the Berkeley
       UNIX C shell, csh(1).  It is a command language interpreter usable both
       as an interactive login shell and a shell script command processor.  It
       includes a command-line editor  (see  The  command-line	editor),  programmable
  word	completion (see Completion and listing), spelling correction
 (see Spelling correction), a  history  mechanism  (see  History
       substitution),  job  control  (see  Jobs) and a C-like syntax.  The NEW
       FEATURES section describes major  enhancements  of  tcsh  over  csh(1).
       Throughout  this  manual,  features  of	tcsh  not found in most csh(1)
       implementations (specifically, the 4.4BSD csh) are labeled with	`(+)',
       and features which are present in csh(1) but not usually documented are
       labeled with `(u)'.

   Argument list processing    [Toc]    [Back]
       If the first argument (argument 0) to the shell is `-'  then  it  is  a
       login shell.  A login shell can be also specified by invoking the shell
       with the -l flag as the only argument.

       The rest of the flag arguments are interpreted as follows:

       -b  Forces a ``break'' from  option  processing,  causing  any  further
	   shell arguments to be treated as non-option arguments.  The remaining
 arguments will not be interpreted as shell options.   This  may
	   be used to pass options to a shell script without confusion or possible
 subterfuge.  The shell will not  run  a  set-user  ID	script
	   without this option.

       -c  Commands  are  read	from  the  following  argument	(which must be
	   present, and must be a single  argument),  stored  in  the  command
	   shell  variable  for  reference, and executed.  Any remaining arguments
 are placed in the argv shell variable.

       -d  The shell loads the directory stack from  ~/.cshdirs  as  described
	   under Startup and shutdown, whether or not it is a login shell. (+)

	   Sets the environment variable name to value. (Domain/OS only) (+)

       -e  The shell exits if any invoked  command  terminates	abnormally  or
	   yields a non-zero exit status.

       -f  The shell ignores ~/.tcshrc, and thus starts faster.

       -F  The	shell  uses  fork(2)  instead  of vfork(2) to spawn processes.
	   (Convex/OS only) (+)

       -i  The shell is interactive and prompts for its top-level input,  even
	   if it appears to not be a terminal.	Shells are interactive without
	   this option if their inputs and outputs are terminals.

       -l  The shell is a login shell.	Applicable only if -l is the only flag

       -m  The	shell loads ~/.tcshrc even if it does not belong to the effective
 user.  Newer versions of su(1) can pass -m to the shell. (+)

       -n  The shell parses commands but does not execute them.  This aids  in
	   debugging shell scripts.

       -q  The shell accepts SIGQUIT (see Signal handling) and behaves when it
	   is used under a debugger.  Job control is disabled. (u)

       -s  Command input is taken from the standard input.

       -t  The shell reads and executes a single line of input.  A `\' may  be
	   used  to  escape  the  newline at the end of this line and continue
	   onto another line.

       -v  Sets the verbose shell variable, so that command  input  is	echoed
	   after history substitution.

       -x  Sets  the  echo shell variable, so that commands are echoed immediately
 before execution.

       -V  Sets the verbose shell variable even before executing ~/.tcshrc.

       -X  Is to -x as -V is to -v.

       After processing of flag arguments, if arguments remain but none of the
       -c,  -i,  -s,  or -t options were given, the first argument is taken as
       the name of a file of commands, or ``script'',  to  be  executed.   The
       shell opens this file and saves its name for possible resubstitution by
       `$0'.  Because many systems use either the standard version 6  or  version
  7	shells whose shell scripts are not compatible with this shell,
       the shell uses such a `standard' shell to execute a script whose  first
       character is not a `#', i.e., that does not start with a comment.

       Remaining arguments are placed in the argv shell variable.

   Startup and shutdown    [Toc]    [Back]
       A  login  shell	begins	by  executing  commands  from the system files
       /etc/csh.cshrc and /etc/csh.login.   It	then  executes	commands  from
       files  in  the  user's  home  directory:  first	~/.tcshrc  (+)	or, if
       ~/.tcshrc is not found, ~/.cshrc, then ~/.history (or the value of  the
       histfile shell variable), then ~/.login, and finally ~/.cshdirs (or the
       value of  the  dirsfile	shell  variable)  (+).	 The  shell  may  read
       /etc/csh.login  before  instead	of  after /etc/csh.cshrc, and ~/.login
       before instead of after ~/.tcshrc or ~/.cshrc  and  ~/.history,	if  so
       compiled; see the version shell variable. (+)

       Non-login  shells read only /etc/csh.cshrc and ~/.tcshrc or ~/.cshrc on

       For examples of startup	files,	please	consult  http://tcshrc.source-

       Commands  like  stty(1)	and  tset(1),  which need be run only once per
       login, usually go in one's ~/.login file.  Users who need  to  use  the
       same  set  of  files with both csh(1) and tcsh can have only a ~/.cshrc
       which checks for the existence of the tcsh shell variable (q.v.) before
       using  tcsh-specific  commands,	or  can  have  both  a	~/.cshrc and a
       ~/.tcshrc which sources (see the builtin command) ~/.cshrc.   The  rest
       of  this manual uses `~/.tcshrc' to mean `~/.tcshrc or, if ~/.tcshrc is
       not found, ~/.cshrc'.

       In the normal case, the shell begins reading commands from  the	terminal,
  prompting with `> '.  (Processing of arguments and the use of the
       shell to process files containing command scripts are described later.)
       The  shell  repeatedly  reads  a  line of command input, breaks it into
       words, places it on the command history list, parses  it  and  executes
       each command in the line.

       One can log out by typing `^D' on an empty line, `logout' or `login' or
       via the shell's autologout mechanism (see the  autologout  shell  variable).
  When a login shell terminates it sets the logout shell variable
       to `normal' or `automatic' as appropriate, then executes commands  from
       the  files  /etc/csh.logout  and  ~/.logout.  The shell may drop DTR on
       logout if so compiled; see the version shell variable.

       The names of the system login and logout files vary from system to system
 for compatibility with different csh(1) variants; see FILES.

   Editing    [Toc]    [Back]
       We  first describe The command-line editor.  The Completion and listing
       and Spelling correction sections describe  two  sets  of  functionality
       that  are  implemented  as  editor commands but which deserve their own
       treatment.  Finally, Editor commands lists  and	describes  the	editor
       commands specific to the shell and their default bindings.

   The command-line editor (+)
       Command-line  input  can  be edited using key sequences much like those
       used in GNU Emacs or vi(1).  The editor is active only  when  the  edit
       shell  variable	is  set, which it is by default in interactive shells.
       The bindkey builtin can display and change key  bindings.   Emacs-style
       key  bindings are used by default (unless the shell was compiled otherwise;
 see the version shell variable), but bindkey can change  the  key
       bindings to vi-style bindings en masse.

       The  shell always binds the arrow keys (as defined in the TERMCAP environment
 variable) to

	   down    down-history
	   up	   up-history
	   left    backward-char
	   right   forward-char

       unless doing so would alter another single-character binding.  One  can
       set  the  arrow	key escape sequences to the empty string with settc to
       prevent these bindings.	The ANSI/VT100 sequences for  arrow  keys  are
       always bound.

       Other  key  bindings are, for the most part, what Emacs and vi(1) users
       would expect and can easily be displayed by bindkey,  so  there	is  no
       need to list them here.	Likewise, bindkey can list the editor commands
       with a short description of each.

       Note that editor commands do not have the same notion of a ``word''  as
       does  the  shell.   The editor delimits words with any non-alphanumeric
       characters not in the shell variable wordchars, while the shell	recognizes
  only whitespace and some of the characters with special meanings
       to it, listed under Lexical structure.

   Completion and listing (+)
       The shell is often able to complete words when given a unique abbreviation.
  Type part of a word (for example `ls /usr/lost') and hit the tab
       key to run the complete-word editor command.  The shell	completes  the
       filename  `/usr/lost'  to  `/usr/lost+found/', replacing the incomplete
       word with the complete word in the input buffer.   (Note  the  terminal
       `/';  completion  adds  a `/' to the end of completed directories and a
       space to the end of other completed words, to speed typing and  provide
       a visual indicator of successful completion.  The addsuffix shell variable
 can be unset to prevent this.)  If	no  match  is  found  (perhaps
       `/usr/lost+found' doesn't exist), the terminal bell rings.  If the word
       is already complete (perhaps there is a `/usr/lost' on your system,  or
       perhaps	you  were  thinking too far ahead and typed the whole thing) a
       `/' or space is added to the end if it isn't already there.

       Completion works anywhere in the line, not at just the  end;  completed
       text  pushes the rest of the line to the right.	Completion in the middle
 of a word often results in leftover characters to the right of  the
       cursor that need to be deleted.

       Commands  and  variables  can  be  completed in much the same way.  For
       example, typing `em[tab]' would complete `em' to `emacs' if emacs  were
       the  only  command  on your system beginning with `em'.	Completion can
       find a command in any directory in path or if given  a  full  pathname.
       Typing  `echo  $ar[tab]'  would	complete  `$ar' to `$argv' if no other
       variable began with `ar'.

       The shell parses the input buffer to determine  whether	the  word  you
       want  to  complete  should be completed as a filename, command or variable.
  The first word in the buffer and the first word  following  `;',
       `|',  `|&',  `&&' or `||' is considered to be a command.  A word beginning
 with `$' is considered to be a variable.  Anything else is a filename.
  An empty line is `completed' as a filename.

       You  can  list the possible completions of a word at any time by typing
       `^D' to run the delete-char-or-list-or-eof editor command.   The  shell
       lists  the  possible completions using the ls-F builtin (q.v.)  and reprints
 the prompt and unfinished command line, for example:

	   > ls /usr/l[^D]
	   lbin/       lib/	   local/      lost+found/
	   > ls /usr/l

       If the autolist shell variable is set, the shell  lists	the  remaining
       choices (if any) whenever completion fails:

	   > set autolist
	   > nm /usr/lib/libt[tab]
	   libtermcap.a@ libtermlib.a@
	   > nm /usr/lib/libterm

       If autolist is set to `ambiguous', choices are listed only when completion
 fails and adds no new characters to the word being completed.

       A filename to be completed can contain variables, your own  or  others'
       home  directories  abbreviated with `~' (see Filename substitution) and
       directory stack entries abbreviated with `=' (see Directory stack  sub-
       stitution).  For example,

	   > ls ~k[^D]
	   kahn    kas	   kellogg
	   > ls ~ke[tab]
	   > ls ~kellogg/


	   > set local = /usr/local
	   > ls $lo[tab]
	   > ls $local/[^D]
	   bin/ etc/ lib/ man/ src/
	   > ls $local/

       Note  that  variables  can also be expanded explicitly with the expand-
       variables editor command.

       delete-char-or-list-or-eof lists at only the end of the	line;  in  the
       middle  of  a  line it deletes the character under the cursor and on an
       empty line it logs one out or,  if  ignoreeof  is  set,	does  nothing.
       `M-^D', bound to the editor command list-choices, lists completion possibilities
 anywhere on a line, and list-choices	(or  any  one  of  the
       related	editor	commands that do or don't delete, list and/or log out,
       listed under delete-char-or-list-or-eof) can be bound to `^D' with  the
       bindkey builtin command if so desired.

       The complete-word-fwd and complete-word-back editor commands (not bound
       to any keys by default) can be used to cycle up and  down  through  the
       list  of possible completions, replacing the current word with the next
       or previous word in the list.

       The shell variable fignore can be set to  a  list  of  suffixes	to  be
       ignored by completion.  Consider the following:

	   > ls
	   Makefile	   condiments.h~   main.o	   side.c
	   README	   main.c	   meal 	   side.o
	   condiments.h    main.c~
	   > set fignore = (.o \~)
	   > emacs ma[^D]
	   main.c   main.c~  main.o
	   > emacs ma[tab]
	   > emacs main.c

       `main.c~'  and  `main.o'  are  ignored by completion (but not listing),
       because they end in suffixes in fignore.  Note that a `\' was needed in
       front  of  `~'  to  prevent it from being expanded to home as described
       under Filename substitution.  fignore is ignored if only one completion
       is possible.

       If  the	complete  shell  variable  is  set to `enhance', completion 1)
       ignores case and 2) considers periods, hyphens  and  underscores  (`.',
       `-'  and  `_')  to be word separators and hyphens and underscores to be
       equivalent.  If you had the following files

	   comp.lang.c	    comp.lang.perl   comp.std.c++
	   comp.lang.c++    comp.std.c

       and typed `mail -f c.l.c[tab]', it  would  be  completed  to  `mail  -f
       comp.lang.c',  and  ^D  would  list  `comp.lang.c' and `comp.lang.c++'.
       `mail -f c..c++[^D]' would  list  `comp.lang.c++'  and  `comp.std.c++'.
       Typing `rm a--file[^D]' in the following directory

	   A_silly_file    a-hyphenated-file	another_silly_file

       would  list  all  three	files, because case is ignored and hyphens and
       underscores are equivalent.  Periods, however, are  not	equivalent  to
       hyphens or underscores.

       Completion  and	listing are affected by several other shell variables:
       recexact can be set to complete on the shortest possible unique	match,
       even if more typing might result in a longer match:

	   > ls
	   fodder   foo      food     foonly
	   > set recexact
	   > rm fo[tab]

       just beeps, because `fo' could expand to `fod' or `foo', but if we type
       another `o',

	   > rm foo[tab]
	   > rm foo

       the completion completes on `foo', even though `food' and `foonly' also
       match.	autoexpand can be set to run the expand-history editor command
       before each completion attempt, autocorrect can be set to spelling-correct
  the  word	to  be completed (see Spelling correction) before each
       completion attempt and correct can be set to complete commands automatically
  after  one hits `return'.  matchbeep can be set to make completion
 beep or not beep in a variety of situations, and nobeep can be set
       to  never  beep	at  all.   nostat  can be set to a list of directories
       and/or patterns that match directories to prevent the completion mechanism
 from stat(2)ing those directories.	listmax and listmaxrows can be
       set to limit the number of  items  and  rows  (respectively)  that  are
       listed  without asking first.  recognize_only_executables can be set to
       make the shell list only executables when listing commands, but	it  is
       quite slow.

       Finally, the complete builtin command can be used to tell the shell how
       to complete words other than filenames, commands and  variables.   Completion
	and listing do not work on glob-patterns (see Filename substi-
       tution), but the list-glob  and	expand-glob  editor  commands  perform
       equivalent functions for glob-patterns.

   Spelling correction (+)
       The shell can sometimes correct the spelling of filenames, commands and
       variable names as well as completing and listing them.

       Individual words can be spelling-corrected with the  spell-word	editor
       command (usually bound to M-s and M-S) and the entire input buffer with
       spell-line (usually bound to M-$).  The correct shell variable  can  be
       set to `cmd' to correct the command name or `all' to correct the entire
       line each time return is typed, and autocorrect can be set  to  correct
       the word to be completed before each completion attempt.

       When  spelling correction is invoked in any of these ways and the shell
       thinks that any part of the command line is misspelled, it prompts with
       the corrected line:

	   > set correct = cmd
	   > lz /usr/bin
	   CORRECT>ls /usr/bin (y|n|e|a)?

       One can answer `y' or space to execute the corrected line, `e' to leave
       the uncorrected command in the input buffer, `a' to abort  the  command
       as if `^C' had been hit, and anything else to execute the original line

       Spelling correction recognizes user-defined completions (see  the  com-
       plete  builtin  command).   If  an input word in a position for which a
       completion is defined resembles a word in the completion list, spelling
       correction  registers  a  misspelling and suggests the latter word as a
       correction.  However, if the input word does not match any of the  possible
  completions for that position, spelling correction does not register
 a misspelling.

       Like completion, spelling correction works anywhere in the line,  pushing
  the rest of the line to the right and possibly leaving extra characters
 to the right of the cursor.

       Beware: spelling correction is not  guaranteed  to  work  the  way  one
       intends,  and  is  provided mostly as an experimental feature.  Suggestions
 and improvements are welcome.

   Editor commands (+)
       `bindkey' lists	key  bindings  and  `bindkey  -l'  lists  and  briefly
       describes  editor  commands.  Only new or especially interesting editor
       commands are described here.  See emacs(1) and vi(1)  for  descriptions
       of each editor's key bindings.

       The  character  or characters to which each command is bound by default
       is given in parentheses.  `^character' means a  control	character  and
       `M-character'  a meta character, typed as escape-character on terminals
       without a meta key.  Case counts, but commands that are bound  to  letters
 by default are bound to both lower- and uppercase letters for convenience.

       complete-word (tab)
	       Completes a word as described under Completion and listing.

       complete-word-back (not bound)
	       Like complete-word-fwd, but steps up from the end of the  list.

       complete-word-fwd (not bound)
	       Replaces  the  current  word with the first word in the list of
	       possible completions.  May be repeated to step down through the
	       list.   At the end of the list, beeps and reverts to the incomplete

       complete-word-raw (^X-tab)
	       Like complete-word, but ignores user-defined completions.

       copy-prev-word (M-^_)
	       Copies the previous word in the current	line  into  the  input
	       buffer.	See also insert-last-word.

       dabbrev-expand (M-/)
	       Expands	the  current word to the most recent preceding one for
	       which the current is a leading substring, wrapping  around  the
	       history	list  (once)  if  necessary.  Repeating dabbrev-expand
	       without any intervening typing changes  to  the	next  previous
	       word etc., skipping identical matches much like history-search-
	       backward does.

       delete-char (not bound)
	       Deletes the character under the cursor.	See also  delete-char-

       delete-char-or-eof (not bound)
	       Does  delete-char  if  there is a character under the cursor or
	       end-of-file on an empty line.  See also delete-char-or-list-or-

       delete-char-or-list (not bound)
	       Does  delete-char  if  there is a character under the cursor or
	       list-choices at the end of the line.  See also  delete-char-or-

       delete-char-or-list-or-eof (^D)
	       Does  delete-char  if  there  is  a character under the cursor,
	       list-choices at the end of the line or end-of-file on an  empty
	       line.  See also those three commands, each of which does only a
	       single action, and delete-char-or-eof, delete-char-or-list  and
	       list-or-eof,  each  of  which  does  a different two out of the

       down-history (down-arrow, ^N)
	       Like up-history, but steps down, stopping at the original input

       end-of-file (not bound)
	       Signals	an  end  of file, causing the shell to exit unless the
	       ignoreeof shell variable (q.v.) is set to  prevent  this.   See
	       also delete-char-or-list-or-eof.

       expand-history (M-space)
	       Expands history substitutions in the current word.  See History
	       substitution.  See also magic-space, toggle-literal-history and
	       the autoexpand shell variable.

       expand-glob (^X-*)
	       Expands	the glob-pattern to the left of the cursor.  See File-
	       name substitution.

       expand-line (not bound)
	       Like expand-history, but expands history substitutions in  each
	       word in the input buffer,

       expand-variables (^X-$)
	       Expands	the  variable to the left of the cursor.  See Variable

       history-search-backward (M-p, M-P)
	       Searches backwards through  the	history  list  for  a  command
	       beginning  with	the current contents of the input buffer up to
	       the cursor and copies it into the  input  buffer.   The	search
	       string  may  be a glob-pattern (see Filename substitution) containing
 `*', `?', `[]' or `{}'.	 up-history  and  down-history
	       will  proceed  from  the appropriate point in the history list.
	       Emacs mode only.  See also history-search-forward and i-search-

       history-search-forward (M-n, M-N)
	       Like history-search-backward, but searches forward.

       i-search-back (not bound)
	       Searches  backward  like  history-search-backward,  copies  the
	       first match into the input buffer with the cursor positioned at
	       the  end of the pattern, and prompts with `bck: ' and the first
	       match.  Additional  characters  may  be	typed  to  extend  the
	       search,	i-search-back  may be typed to continue searching with
	       the same pattern, wrapping around the history  list  if	necessary,
  (i-search-back  must  be bound to a single character for
	       this to work) or one of the following special characters may be

		   ^W	   Appends  the  rest  of the word under the cursor to
			   the search pattern.
		   delete (or any character bound to backward-delete-char)
			   Undoes the effect of the last character  typed  and
			   deletes  a  character  from	the  search pattern if
		   ^G	   If the previous search was successful,  aborts  the
			   entire  search.  If not, goes back to the last successful
		   escape  Ends the search, leaving the current  line  in  the
			   input buffer.

	       Any other character not bound to self-insert-command terminates
	       the search, leaving the current line in the input  buffer,  and
	       is then interpreted as normal input.  In particular, a carriage
	       return causes the current line  to  be  executed.   Emacs  mode
	       only.  See also i-search-fwd and history-search-backward.

       i-search-fwd (not bound)
	       Like i-search-back, but searches forward.

       insert-last-word (M-_)
	       Inserts	the  last  word of the previous input line (`!$') into
	       the input buffer.  See also copy-prev-word.

       list-choices (M-^D)
	       Lists completion possibilities as  described  under  Completion
	       and  listing.   See  also  delete-char-or-list-or-eof and list-

       list-choices-raw (^X-^D)
	       Like list-choices, but ignores user-defined completions.

       list-glob (^X-g, ^X-G)
	       Lists (via the ls-F builtin) matches to the  glob-pattern  (see
	       Filename substitution) to the left of the cursor.

       list-or-eof (not bound)
	       Does  list-choices  or  end-of-file on an empty line.  See also

       magic-space (not bound)
	       Expands history substitutions in the current line, like expand-
	       history,  and  appends  a space.  magic-space is designed to be
	       bound to the space bar, but is not bound by default.

       normalize-command (^X-?)
	       Searches for the current word in PATH  and,  if	it  is	found,
	       replaces  it  with  the	full  path to the executable.  Special
	       characters are quoted.  Aliases are  expanded  and  quoted  but
	       commands  within  aliases are not.  This command is useful with
	       commands that take commands as arguments, e.g., `dbx'  and  `sh

       normalize-path (^X-n, ^X-N)
	       Expands	the  current word as described under the `expand' setting
 of the symlinks shell variable.

       overwrite-mode (unbound)
	       Toggles between input and overwrite modes.

       run-fg-editor (M-^Z)
	       Saves the current input line and looks for a stopped job with a
	       name  equal  to the last component of the file name part of the
	       EDITOR or VISUAL environment variables, or, if neither is  set,
	       `ed'  or  `vi'.	 If such a job is found, it is restarted as if
	       `fg %job' had been typed.  This is  used  to  toggle  back  and
	       forth between an editor and the shell easily.  Some people bind
	       this command to `^Z' so they can do this even more easily.

       run-help (M-h, M-H)
	       Searches for documentation on the current  command,  using  the
	       same  notion  of  `current command' as the completion routines,
	       and prints it.  There is no way to use  a  pager;  run-help  is
	       designed  for  short help files.  If the special alias helpcom-
	       mand is defined, it is run with the  command  name  as  a  sole
	       argument.   Else,  documentation should be in a file named com-
	       mand.help, command.1, command.6, command.8  or  command,  which
	       should  be  in one of the directories listed in the HPATH environment
 variable.  If there is more than one help file only the
	       first is printed.

       self-insert-command (text characters)
	       In  insert mode (the default), inserts the typed character into
	       the input line after the character under the cursor.  In  overwrite
  mode,  replaces  the character under the cursor with the
	       typed character.  The input mode is normally preserved  between
	       lines,  but the inputmode shell variable can be set to `insert'
	       or `overwrite' to put the editor in that mode at the  beginning
	       of each line.  See also overwrite-mode.

       sequence-lead-in (arrow prefix, meta prefix, ^X)
	       Indicates that the following characters are part of a multi-key
	       sequence.  Binding a command to	a  multi-key  sequence	really
	       creates	two  bindings: the first character to sequence-lead-in
	       and the whole sequence to the command.  All sequences beginning
	       with  a	character  bound  to  sequence-lead-in are effectively
	       bound to undefined-key unless bound to another command.

       spell-line (M-$)
	       Attempts to correct the spelling of  each  word	in  the  input
	       buffer,	like spell-word, but ignores words whose first character
 is one of `-', `!', `^' or `%', or which contain  `\',  `*'
	       or  `?', to avoid problems with switches, substitutions and the
	       like.  See Spelling correction.

       spell-word (M-s, M-S)
	       Attempts to  correct  the  spelling  of	the  current  word  as
	       described  under Spelling correction.  Checks each component of
	       a word which appears to be a pathname.

       toggle-literal-history (M-r, M-R)
	       Expands or  `unexpands'	history  substitutions	in  the  input
	       buffer.	See also expand-history and the autoexpand shell variable.

       undefined-key (any unbound key)

       up-history (up-arrow, ^P)
	       Copies the previous entry in the history list  into  the  input
	       buffer.	If histlit is set, uses the literal form of the entry.
	       May be repeated to step up through the history  list,  stopping
	       at the top.

       vi-search-back (?)
	       Prompts	with `?' for a search string (which may be a glob-pattern,
 as with history-search-backward),	searches  for  it  and
	       copies it into the input buffer.  The bell rings if no match is
	       found.  Hitting return ends the	search	and  leaves  the  last
	       match  in the input buffer.  Hitting escape ends the search and
	       executes the match.  vi mode only.

       vi-search-fwd (/)
	       Like vi-search-back, but searches forward.

       which-command (M-?)
	       Does a which (see the description of the  builtin  command)  on
	       the first word of the input buffer.

   Lexical structure    [Toc]    [Back]
       The  shell  splits input lines into words at blanks and tabs.  The special
 characters `&', `|', `;', `<', `>', `(', and `)' and  the  doubled
       characters `&&', `||', `<<' and `>>' are always separate words, whether
       or not they are surrounded by whitespace.

       When the shell's input is not a terminal, the character `#' is taken to
       begin  a  comment.  Each `#' and the rest of the input line on which it
       appears is discarded before further parsing.

       A special character (including a blank or tab) may  be  prevented  from
       having  its special meaning, and possibly made part of another word, by
       preceding it with a backslash (`\') or enclosing it  in	single	(`''),
       double  (`"')  or  backward  (``') quotes.  When not otherwise quoted a
       newline preceded by a `\' is equivalent to a blank, but	inside	quotes
       this sequence results in a newline.

       Furthermore,  all Substitutions (see below) except History substitution
       can be prevented by enclosing the strings  (or  parts  of  strings)  in
       which  they appear with single quotes or by quoting the crucial character(s)
 (e.g., `$' or ``' for Variable substitution or Command substitu-
       tion  respectively)  with  `\'.	 (Alias  substitution is no exception:
       quoting in any way any character of a word for which an alias has  been
       defined	prevents  substitution of the alias.  The usual way of quoting
       an alias is to precede it with a backslash.)  History  substitution  is
       prevented by backslashes but not by single quotes.  Strings quoted with
       double or backward quotes undergo  Variable  substitution  and  Command
       substitution, but other substitutions are prevented.

       Text  inside  single or double quotes becomes a single word (or part of
       one).  Metacharacters in these strings, including blanks and  tabs,  do
       not form separate words.  Only in one special case (see Command substi-
       tution below) can a double-quoted string yield parts of more  than  one
       word;  single-quoted  strings  never  do.  Backward quotes are special:
       they signal Command substitution (q.v.), which may result in more  than
       one word.

       Quoting	complex strings, particularly strings which themselves contain
       quoting characters, can be confusing.  Remember that quotes need not be
       used  as  they  are in human writing!  It may be easier to quote not an
       entire string, but only those parts of the string which	need  quoting,
       using different types of quoting to do so if appropriate.

       The  backslash_quote  shell  variable  (q.v.)  can be set to make backslashes
 always quote `\', `'', and `"'.	 (+)  This  may  make  complex
       quoting tasks easier, but it can cause syntax errors in csh(1) scripts.

   Substitutions    [Toc]    [Back]
       We now describe the various transformations the shell performs  on  the
       input  in  the  order in which they occur.  We note in passing the data
       structures involved and the commands and variables which  affect  them.
       Remember  that  substitutions  can be prevented by quoting as described
       under Lexical structure.

   History substitution    [Toc]    [Back]
       Each command, or ``event'', input from the terminal  is	saved  in  the
       history	list.	The  previous command is always saved, and the history
       shell variable can be set to a number to save that many commands.   The
       histdup	shell variable can be set to not save duplicate events or consecutive
 duplicate events.

       Saved commands are numbered sequentially from 1 and  stamped  with  the
       time.   It  is not usually necessary to use event numbers, but the current
 event number can be made part of the prompt by placing an  `!'  in
       the prompt shell variable.

       The  shell  actually saves history in expanded and literal (unexpanded)
       forms.  If the histlit shell variable is set, commands that display and
       store history use the literal form.

       The  history  builtin  command  can print, store in a file, restore and
       clear the history list at any time, and the savehist and histfile shell
       variables  can be can be set to store the history list automatically on
       logout and restore it on login.

       History substitutions introduce words from the history  list  into  the
       input  stream, making it easy to repeat commands, repeat arguments of a
       previous command in the current command, or fix	spelling  mistakes  in
       the  previous  command  with  little typing and a high degree of confidence.

       History substitutions begin with the character  `!'.   They  may  begin
       anywhere  in  the  input  stream, but they do not nest.	The `!' may be
       preceded by a `\' to prevent its special meaning;  for  convenience,  a
       `!'  is	passed unchanged when it is followed by a blank, tab, newline,
       `=' or `('.  History substitutions also occur when an input line begins
       with  `^'.   This  special  abbreviation  will be described later.  The
       characters used to signal history substitution (`!'  and  `^')  can  be
       changed	by setting the histchars shell variable.  Any input line which
       contains a history substitution is printed before it is executed.

       A history substitution may have an ``event specification'', which indicates
  the  event  from	which words are to be taken, a ``word designator'',
 which selects particular words from the chosen event,  and/or  a
       ``modifier'', which manipulates the selected words.

       An event specification can be

	   n	   A number, referring to a particular event
	   -n	   An  offset,	referring  to  the  event n before the current
	   #	   The current	event.	 This  should  be  used  carefully  in
		   csh(1), where there is no check for recursion.  tcsh allows
		   10 levels of recursion.  (+)
	   !	   The previous event (equivalent to `-1')
	   s	   The most recent event whose	first  word  begins  with  the
		   string s
	   ?s?	   The	most  recent  event  which contains the string s.  The
		   second `?' can be omitted if it is immediately followed  by
		   a newline.

       For example, consider this bit of someone's history list:

	    9  8:30    nroff -man wumpus.man
	   10  8:31    cp wumpus.man wumpus.man.old
	   11  8:36    vi wumpus.man
	   12  8:37    diff wumpus.man.old wumpus.man

       The  commands  are shown with their event numbers and time stamps.  The
       current event, which we haven't typed in yet, is event 13.   `!11'  and
       `!-2'  refer to event 11.  `!!' refers to the previous event, 12.  `!!'
       can be abbreviated `!' if it is	followed  by  `:'  (`:'  is  described
       below).	 `!n' refers to event 9, which begins with `n'.  `!?old?' also
       refers to event 12, which contains `old'.  Without word designators  or
       modifiers  history  references simply expand to the entire event, so we
       might type `!cp' to redo the copy command or `!!|more'  if  the	`diff'
       output scrolled off the top of the screen.

       History	references  may  be  insulated	from the surrounding text with
       braces if necessary.  For example, `!vdoc' would  look  for  a  command
       beginning  with	`vdoc',  and,  in  this  example,  not	find  one, but
       `!{v}doc' would expand unambiguously to `vi  wumpus.mandoc'.   Even  in
       braces, history substitutions do not nest.

       (+) While csh(1) expands, for example, `!3d' to event 3 with the letter
       `d' appended to it, tcsh expands it to the last	event  beginning  with
       `3d';  only  completely numeric arguments are treated as event numbers.
       This makes it possible to recall events	beginning  with  numbers.   To
       expand `!3d' as in csh(1) say `!\3d'.

       To  select words from an event we can follow the event specification by
       a `:' and a designator for the desired words.  The words  of  an  input
       line are numbered from 0, the first (usually command) word being 0, the
       second word (first argument) being 1, etc.  The basic word  designators

	   0	   The first (command) word
	   n	   The nth argument
	   ^	   The first argument, equivalent to `1'
	   $	   The last argument
	   %	   The word matched by an ?s? search
	   x-y	   A range of words
	   -y	   Equivalent to `0-y'
	   *	   Equivalent  to `^-$', but returns nothing if the event contains
 only 1 word
	   x*	   Equivalent to `x-$'
	   x-	   Equivalent to `x*', but omitting the last word (`$')

       Selected words are inserted into the command line separated  by	single
       blanks.	 For example, the `diff' command in the previous example might
       have been typed as `diff !!:1.old !!:1' (using `:1' to select the first
       argument  from  the previous event) or `diff !-2:2 !-2:1' to select and
       swap the arguments from the `cp' command.  If we didn't care about  the
       order  of  the `diff' we might have said `diff !-2:1-2' or simply `diff
       !-2:*'.	The `cp'  command  might  have	been  written  `cp  wumpus.man
       !#:1.old',  using `#' to refer to the current event.  `!n:- hurkle.man'
       would reuse the first two words from the `nroff' command to say	`nroff
       -man hurkle.man'.

       The `:' separating the event specification from the word designator can
       be omitted if the argument selector begins with a `^', `$', `*', `%' or
       `-'.   For  example,  our  `diff' command might have been `diff !!^.old
       !!^' or, equivalently, `diff !!$.old !!$'.  However, if `!!' is	abbreviated
 `!', an argument selector beginning with `-' will be interpreted
       as an event specification.

       A history reference may have a word designator but no event  specification.
   It then references the previous command.  Continuing our `diff'
       example, we could have said simply `diff !^.old	!^'  or,  to  get  the
       arguments in the opposite order, just `diff !*'.

       The  word  or  words  in  a history reference can be edited, or ``modified'',
 by following it with one or more modifiers, each preceded by  a

	   h	   Remove a trailing pathname component, leaving the head.
	   t	   Remove all leading pathname components, leaving the tail.
	   r	   Remove  a filename extension `.xxx', leaving the root name.
	   e	   Remove all but the extension.
	   u	   Uppercase the first lowercase letter.
	   l	   Lowercase the first uppercase letter.
	   s/l/r/  Substitute l for r.	l is simply a string  like  r,	not  a
		   regular  expression as in the eponymous ed(1) command.  Any
		   character may be used as the delimiter in place of  `/';  a
		   `\' can be used to quote the delimiter inside l and r.  The
		   character `&' in the r is replaced by l;  `\'  also	quotes
		   `&'.  If l is empty (``''), the l from a previous substitution
 or the s from a previous `?s?' event specification  is
		   used.  The trailing delimiter may be omitted if it is immediately
 followed by a newline.
	   &	   Repeat the previous substitution.
	   g	   Apply the following modifier once to each word.
	   a (+)   Apply the following modifier as many times as possible to a
		   single  word.   `a' and `g' can be used together to apply a
		   modifier globally.  In the  current	implementation,  using
		   the	`a' and `s' modifiers together can lead to an infinite
		   loop.  For example, `:as/f/ff/' will never terminate.  This
		   behavior might change in the future.
	   p	   Print the new command line but do not execute it.
	   q	   Quote  the  substituted words, preventing further substitutions.

	   x	   Like q, but break into words at blanks, tabs and  newlines.

       Modifiers  are applied to only the first modifiable word (unless `g' is
       used).  It is an error for no word to be modifiable.

       For example, the `diff' command might have been written as  `diff  wumpus.man.old
 !#^:r', using `:r' to remove `.old' from the first argument
       on the same line (`!#^').  We could say `echo hello  out  there',  then
       `echo  !*:u' to capitalize `hello', `echo !*:au' to say it out loud, or
       `echo !*:agu' to really shout.  We might follow `mail -s "I  forgot  my
       password"  rot'	with  `!:s/rot/root' to correct the spelling of `root'
       (but see Spelling correction for a different approach).

       There is a special abbreviation for substitutions.  `^', when it is the
       first  character  on  an  input line, is equivalent to `!:s^'.  Thus we
       might have said `^rot^root' to make the spelling correction in the previous
  example.	 This  is the only history substitution which does not
       explicitly begin with `!'.

       (+) In csh as such, only one modifier may be applied to each history or
       variable expansion.  In tcsh, more than one may be used, for example

	   % mv wumpus.man /usr/man/man1/wumpus.1
	   % man !$:t:r
	   man wumpus

       In csh, the result would be `wumpus.1:r'.  A substitution followed by a
       colon may need to be insulated from it with braces:

	   > mv a.out /usr/games/wumpus
	   > setenv PATH !$:h:$PATH
	   Bad ! modifier: $.
	   > setenv PATH !{-2$:h}:$PATH
	   setenv PATH /usr/games:/bin:/usr/bin:.

       The first attempt would succeed in csh but fails in tcsh, because  tcsh
       expects another modifier after the second colon rather than `$'.

       Finally,  history can be accessed through the editor as well as through
       the substitutions just described.  The up- and  down-history,  history-
       search-backward	and  -forward,	i-search-back and -fwd, vi-search-back
       and -fwd, copy-prev-word and insert-last-word  editor  commands	search
       for  events  in	the  history list and copy them into the input buffer.
       The toggle-literal-history editor command switches between the expanded
       and literal forms of history lines in the input buffer.	expand-history
       and expand-line expand history substitutions in the current word and in
       the entire input buffer respectively.

   Alias substitution    [Toc]    [Back]
       The  shell  maintains  a  list  of  aliases which can be set, unset and
       printed by the alias and unalias commands.  After  a  command  line  is
       parsed  into simple commands (see Commands) the first word of each command,
 left-to-right, is checked to see if it has an alias.  If so,  the
       first  word  is replaced by the alias.  If the alias contains a history
       reference, it undergoes History substitution (q.v.) as though the original
  command were the previous input line.  If the alias does not contain
 a history reference, the argument list is left untouched.

       Thus if the alias for `ls' were `ls -l' the  command  `ls  /usr'  would
       become  `ls -l /usr', the argument list here being undisturbed.	If the
       alias for `lookup' were `grep !^ /etc/passwd' then `lookup bill'  would
       become  `grep  bill  /etc/passwd'.   Aliases  can  be used to introduce
       parser metasyntax.  For example, `alias print 'pr \!* | lpr'' defines a
       ``command'' (`print') which pr(1)s its arguments to the line printer.

       Alias  substitution is repeated until the first word of the command has
       no alias.  If an alias substitution does not change the first word  (as
       in  the previous example) it is flagged to prevent a loop.  Other loops
       are detected and cause an error.

       Some aliases are referred to by the shell; see Special aliases.

   Variable substitution    [Toc]    [Back]
       The shell maintains a list of variables, each of which has as  value  a
       list  of zero or more words.  The values of shell variables can be displayed
 and changed with the set and unset commands.  The  system  maintains
  its  own	list  of ``environment'' variables.  These can be displayed
 and changed with printenv, setenv and unsetenv.

       (+) Variables may be made read-only with  `set  -r'  (q.v.)   Read-only
       variables  may not be modified or unset; attempting to do so will cause
       an error.  Once made read-only, a variable cannot be made writable,  so
       `set  -r' should be used with caution.  Environment variables cannot be
       made read-only.

       Some variables are set  by  the	shell  or  referred  to  by  it.   For
       instance,  the  argv variable is an image of the shell's argument list,
       and words of this variable's value are referred	to  in	special  ways.
       Some  of  the variables referred to by the shell are toggles; the shell
       does not care what their value is, only whether they are  set  or  not.
       For  instance,  the  verbose  variable is a toggle which causes command
       input to be echoed.  The -v command line  option  sets  this  variable.
       Special	shell  variables  lists all variables which are referred to by
       the shell.

       Other operations treat variables numerically.  The `@' command  permits
       numeric calculations to be performed and the result assigned to a variable.
  Variable values are, however, always  represented  as  (zero  or
       more) strings.  For the purposes of numeric operations, the null string
       is considered to be zero, and the second and subsequent words of multiword
 values are ignored.

       After  the input line is aliased and parsed, and before each command is
       executed, variable substitution is performed keyed by  `$'  characters.
       This  expansion can be prevented by preceding the `$' with a `\' except
       within `"'s where it always occurs, and	within	`''s  where  it  never
       occurs.	 Strings quoted by ``' are interpreted later (see Command sub-
       stitution below) so `$' substitution does not occur there until	later,
       if  at  all.  A `$' is passed unchanged if followed by a blank, tab, or

       Input/output redirections are recognized before variable expansion, and
       are  variable  expanded	separately.   Otherwise,  the command name and
       entire argument list are expanded together.  It is  thus  possible  for
       the  first  (command)  word  (to  this point) to generate more than one
       word, the first of which becomes the command  name,  and  the  rest  of
       which become arguments.

       Unless  enclosed in `"' or given the `:q' modifier the results of variable
 substitution may eventually be command and	filename  substituted.
       Within  `"',  a variable whose value consists of multiple words expands
       to a (portion of a) single word, with the words of the variable's value
       separated  by blanks.  When the `:q' modifier is applied to a substitution
 the variable will expand to multiple words with  each  word  separated
  by  a blank and quoted to prevent later command or filename substitution.

       The following metasequences are provided for introducing variable  values
 into the shell input.  Except as noted, it is an error to reference
       a variable which is not set.

       ${name} Substitutes the words of the value of variable name, each separated
  by a blank.  Braces insulate name from following characters
 which would otherwise be part of it.  Shell variables have
	       names consisting of up to 20 letters and digits starting with a
	       letter.	The underscore character is considered a  letter.   If
	       name  is  not  a shell variable, but is set in the environment,
	       then that value is returned (but `:' modifiers  and  the  other
	       forms given below are not available in this case).
	       Substitutes  only  the  selected  words from the value of name.
	       The selector is subjected to `$' substitution and  may  consist
	       of  a  single  number  or  two numbers separated by a `-'.  The
	       first word of a variable's value is numbered `1'.  If the first
	       number  of  a range is omitted it defaults to `1'.  If the last
	       member of a range is omitted  it  defaults  to  `$#name'.   The
	       selector `*' selects all words.	It is not an error for a range
	       to be empty if the second argument is omitted or in range.
       $0      Substitutes the name of the file from which  command  input  is
	       being read.  An error occurs if the name is not known.
	       Equivalent to `$argv[number]'.
       $*      Equivalent to `$argv', which is equivalent to `$argv[*]'.

       The  `:'  modifiers  described  under  History substitution, except for
       `:p', can be applied to the substitutions above.  More than one may  be
       used.   (+)  Braces  may  be needed to insulate a variable substitution
       from a literal colon just as with History substitution (q.v.); any modifiers
 must appear within the braces.

       The following substitutions can not be modified with `:' modifiers.

	       Substitutes the string `1' if name is set, `0' if it is not.
       $?0     Substitutes  `1' if the current input filename is known, `0' if
	       it is not.  Always `0' in interactive shells.
	       Substitutes the number of words in name.
       $#      Equivalent to `$#argv'.	(+)
	       Substitutes the number of characters in name.  (+)
	       Substitutes the number of characters in $argv[number].  (+)
       $?      Equivalent to `$status'.  (+)
       $$      Substitutes the (decimal) process number of the (parent) shell.
       $!      Substitutes the (decimal) process number of the last background
	       process started by this shell.  (+)
       $_      Substitutes the command line of the last command executed.  (+)
       $<      Substitutes  a  line  from  the standard input, with no further
	       interpretation thereafter.  It can be used  to  read  from  the
	       keyboard in a shell script.  (+) While csh always quotes $<, as
	       if it were equivalent to `$<:q', tcsh does  not.   Furthermore,
	       when  tcsh  is waiting for a line to be typed the user may type
	       an interrupt to interrupt the sequence into which the  line  is
	       to be substituted, but csh does not allow this.

       The  editor  command expand-variables, normally bound to `^X-$', can be
       used to interactively expand individual variables.

   Command, filename and directory stack substitution
       The remaining substitutions are applied selectively to the arguments of
       builtin	commands.   This  means that portions of expressions which are
       not evaluated are not subjected	to  these  expansions.	 For  commands
       which  are  not	internal to the shell, the command name is substituted
       separately from the argument list.  This occurs very late, after inputoutput
 redirection is performed, and in a child of the main shell.

   Command substitution    [Toc]    [Back]
       Command	substitution  is  indicated by a command enclosed in ``'.  The
       output from such a command is broken into  separate  words  at  blanks,
       tabs  and  newlines, and null words are discarded.  The output is variable
 and command substituted and put in place of the original string.

       Command substitutions inside double  quotes  (`"')  retain  blanks  and
       tabs; only newlines force new words.  The single final newline does not
       force a new word in any case.  It is thus possible for a  command  substitution
  to  yield only part of a word, even if the command outputs a
       complete line.

   Filename substitution    [Toc]    [Back]
       If a word contains any of the characters `*', `?', `[' or `{' or begins
       with  the  character  `~'  it is a candidate for filename substitution,
       also known as ``globbing''.  This word is then regarded	as  a  pattern
       (``glob-pattern''),  and replaced with an alphabetically sorted list of
       file names which match the pattern.

       In matching filenames, the character `.' at the beginning of a filename
       or  immediately	following  a `/', as well as the character `/' must be
       matched explicitly.  The character `*' matches any  string  of  characters,
  including the null string.  The character `?' matches any single
       character.  The sequence `[...]' matches  any  one  of  the  characters
       enclosed.   Within  `[...]',  a	pair  of  characters  separated by `-'
       matches any character lexically between the two.

       (+) Some glob-patterns can be negated: The  sequence  `[^...]'  matches
       any  single  character not specified by the characters and/or ranges of
       characters in the braces.

       An entire glob-pattern can also be negated with `^':

	   > echo *
	   bang crash crunch ouch
	   > echo ^cr*
	   bang ouch

       Glob-patterns which do not use `?', `*', or `[]' or which use  `{}'  or
       `~' (below) are not negated correctly.

       The  metanotation  `a{b,c,d}e' is a shorthand for `abe ace ade'.  Leftto-right
 order is preserved: `/usr/source/s1/{oldls,ls}.c'  expands  to
       `/usr/source/s1/oldls.c	/usr/source/s1/ls.c'.	The results of matches
       are  sorted  separately	at  a  low  level  to  preserve  this	order:
       `../{memo,*box}'  might expand to `../memo ../box ../mbox'.  (Note that
       `memo' was not sorted with the results of matching `*box'.)  It is  not
       an  error  when this construct expands to files which do not exist, but
       it is possible to get an error from a command  to  which  the  expanded
       list  is  passed.  This construct may be nested.  As a special case the
       words `{', `}' and `{}' are passed undisturbed.

       The character `~' at the beginning of a filename refers to home	directories.
	 Standing  alone,  i.e., `~', it expands to the invoker's home
       directory as reflected in the value of the home shell  variable.   When
       followed by a name consisting of letters, digits and `-' characters the
       shell searches for a user with that name  and  substitutes  their  home
       directory;  thus `~ken' might expand to `/usr/ken' and `~ken/chmach' to
       `/usr/ken/chmach'.  If the character `~' is  followed  by  a  character
       other  than  a letter or `/' or appears elsewhere than at the beginning
       of a word, it is left undisturbed.   A  command	like  `setenv  MANPATH

 Similar pages
Name OS Title
tcsh IRIX shell with file name completion and command line editing
VkForkIO IRIX Command-line interface to shell command component
edit Tru64 Edits a file line by line with a simplified command set
readline OpenBSD get a line from a user with editing
readline FreeBSD get a line from a user with editing
glfinishasyncsgix IRIX wait for completion of an asynchronous command
glpollasyncsgix IRIX poll for completion of an asynchronous command
sh Tru64 Shell, the standard command language interpreter (POSIX Shell)
sh Tru64 The Bourne shell, an interactive command interpreter and command programming language
Rsh Tru64 The Bourne shell, an interactive command interpreter and command programming language
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service