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

  man pages->OpenBSD man pages -> fg (1)              



NAME    [Toc]    [Back]

     csh - a shell (command interpreter) with C-like syntax

SYNOPSIS    [Toc]    [Back]

     csh [-bcefimnstvVxX] [argument ...]
     csh [-l]

DESCRIPTION    [Toc]    [Back]

     csh is a command language interpreter incorporating a history mechanism
     (see  History  substitutions),  job  control facilities (see
Jobs), interactive
 file name and  user  name  completion  (see  File  name
completion), and a
     C-like  syntax.   It  is  used  both as an interactive login
shell and a shell
     script command processor.

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

     The rest of the flag arguments are interpreted as follows:

     -b     This flag forces a ``break'' from option  processing,
causing any
            further  shell  arguments to be treated as non-option
            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 (single) following argument which must
            be present.  Any remaining arguments  are  placed  in

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

     -f     The shell will start faster, because it will  neither
search for
            nor  execute commands from the file .cshrc in the invoker's home

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

     -l      The shell is a login shell (only applicable if -l is
the only flag

     -m     Read .cshrc, regardless of its owner and group.  This
option is
            dangerous and should only be used by su(1).

     -n      Commands are parsed, but not executed.  This aids in
            checking of shell scripts.  When used  interactively,
the shell can
            be  terminated  by  pressing  control-D  (end-of-file
character), since
            exit will not work.

     -s     Command input is taken from the standard input.

     -t     A single line of input is read and executed.  A backslash (`')
            may  be used to escape the newline at the end of this
line and continue
 onto another line.

     -v     Causes the verbose variable to be set, with  the  effect that command
 input is echoed after history substitution.

     -x      Causes the echo variable to be set, so that commands
are echoed
            immediately before execution.

     -V     Causes the verbose variable to  be  set  even  before
.cshrc is executed.

     -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 to be executed.  The shell opens
this file,
     and saves its name  for  possible  resubstitution  by  `$0'.
Since many systems
  use  either the standard version 6 or version 7 shells
whose shell
     scripts are not compatible with this shell, the  shell  will
execute such a
     ``standard'' shell if the first character of a script is not
a hash mark
     (`#'); i.e., if the script does not start  with  a  comment.
Remaining arguments
 initialize the variable argv.

     An  instance  of  csh  begins by executing commands from the
     /etc/csh.cshrc   and,   if   this   is   a   login    shell,
/etc/csh.login.  It then
     executes  commands  from .cshrc in the home directory of the
invoker, and,
     if this is a login shell, the file .login in the same  location.  It is
     typical  for  users  on  CRTs to put the command stty crt in
their .login
     file, and to also invoke tset(1) there.

     In the normal case, the shell will  begin  reading  commands
from the terminal,
  prompting  with  `% .' Processing of arguments and the
use of the
     shell to process files containing command  scripts  will  be
described later.

     The  shell repeatedly performs the following actions: a line
of command
     input is read and broken into ``words''.  This  sequence  of
words is
     placed on the command history list and parsed.  Finally each
command in
     the current line is executed.

     When a login shell terminates it executes commands from  the
files .logout
     in the user's home directory and /etc/csh.logout.

   Lexical structure    [Toc]    [Back]
     The  shell  splits input lines into words at blanks and tabs
with the following
 exceptions.  The characters `&', `|', `;', `<',  `>',
`(', and `)'
     form  separate  words.   If  doubled in `&&', `||', `<<', or
`>>', these
     pairs form single words.  These parser metacharacters may be
made part of
     other  words,  or  have  their special meaning prevented, by
preceding them
     with a backslash (`').  A newline preceded by a `' is equivalent to a

     Strings  enclosed  in matched pairs of quotations, `'', ``',
or `"', form
     parts of a word; metacharacters in these strings,  including
blanks and
     tabs, do not form separate words.  These quotations have semantics to be
     described later.  Within pairs of `'' or `"'  characters,  a
newline preceded
 by a `' gives a true newline character.

     When  the shell's input is not a terminal, the character `#'
introduces a
     comment that continues to the end of the input  line.   This
special meaning
 is prevented when preceded by `' and in quotations using
``', `'',
     and `"'.

   Commands    [Toc]    [Back]
     A simple command is a sequence of words, the first of  which
specifies the
     command  to  be executed.  A simple command or a sequence of
simple commands
 separated by `|' characters  forms  a  pipeline.   The
output of each
     command in a pipeline is connected to the input of the next.
     of pipelines may be separated by `;', and are then  executed
     A  sequence of pipelines may be executed without immediately
waiting for
     it to terminate by following it with a `&'.

     Any of the above may be placed in `(' `)' to form  a  simple
command (that
     may  be a component of a pipeline, for example).  It is also
possible to
     separate pipelines with `||' or `&&' showing, as  in  the  C
language, that
     the second is to be executed only if the first fails or succeeds, respectively.
  (See Expressions.)

   Jobs    [Toc]    [Back]
     The shell associates a job with each pipeline.  It  keeps  a
table of current
  jobs,  printed  by  the jobs command, and assigns them
small integer
     numbers.  When a job is started asynchronously with `&', the
shell prints
     a line that looks like:

           [1] 1234

     showing  that  the  job which was started asynchronously was
job number 1
     and had one (top-level) process, whose process ID was  1234.

     If  you  are running a job and wish to do something else you
may hit ^Z
     (control-Z), which sends a SIGSTOP  signal  to  the  current
job.  The shell
     will  then  normally show that the job has been ``Stopped'',
and print another
 prompt.  You can then manipulate  the  state  of  this
job, putting it
     in  the  background  with  the bg command, or run some other
commands and
     eventually bring the job back into the foreground  with  the
fg command.  A
     ^Z takes effect immediately and is like an interrupt in that
pending output
 and unread input are discarded when it is typed.   There
is another
     special key ^Y that does not generate a SIGSTOP signal until
a program
     attempts to read(2) it.  This request can usefully be  typed
ahead when
     you  have  prepared some commands for a job that you wish to
stop after it
     has read them.

     A job being run in the background will stop if it  tries  to
read from the
     terminal.   Background  jobs are normally allowed to produce
output, but
     this can be disabled by giving the command stty tostop.   If
you set this
     tty  option, then background jobs will stop when they try to
produce output
 like they do when they try to read input.

     There are several ways to refer to jobs in the  shell.   The
character `%'
     introduces  a  job name.  If you wish to refer to job number
1, you can
     name it as `%1'.  Just naming a job brings it to  the  foreground; thus %1
     is  a synonym for fg %1, bringing job number 1 back into the
     Similarly, saying %1 & resumes job number  1  in  the  background.  Jobs can
     also  be  named  by prefixes of the string typed in to start
them, if these
     prefixes are unambiguous; thus %ex would normally restart  a
     ex(1)  job,  if there were only one suspended job whose name
began with the
     string "ex".  It is also possible  to  say  %?string,  which
specifies a job
     whose text contains string, if there is only one such job.

     The  shell  maintains  a  notion of the current and previous
jobs.  In output
     about jobs, the current job is marked with  a  `+'  and  the
previous job
     with a `-'.  The abbreviation `%+' refers to the current job
and `%-'
     refers to the previous job.  For close analogy with the syntax of the
     history  mechanism (described below), `%%' is also a synonym
for the current

     The job control mechanism requires that the  stty(1)  option
new be set.
     It is an artifact from a new implementation of the tty driver that allows
     generation of interrupt characters from the keyboard to tell
jobs to
     stop.  See stty(1) for details on setting options in the new
tty driver.

   Status reporting    [Toc]    [Back]
     The shell learns  immediately  whenever  a  process  changes
state.  It normally
  informs you whenever a job becomes blocked so that no
     progress is possible, but  only  just  before  it  prints  a
prompt.  This is
     done  so  that it does not otherwise disturb your work.  If,
however, you
     set the shell variable notify, the shell will notify you immediately of
     changes of status in background jobs.  There is also a shell
     notify that marks  a  single  process  so  that  its  status
changes will be immediately
  reported.   By  default  notify marks the current
process; simply
     say notify after starting a background job to mark it.

     When you try to leave the shell while jobs are stopped,  you
will be
     warned that ``You have stopped jobs''.  You may use the jobs
command to
     see what they are.  If you try to  exit  again  immediately,
the shell will
     not  warn  you a second time, and the suspended jobs will be

   File name completion    [Toc]    [Back]
     When the file name completion feature is enabled by  setting
the shell
     variable  filec  (see  set), csh will interactively complete
file names and
     user names from unique prefixes when they are input from the
     followed  by  the  escape character (the escape key, or control-[).  For example,
 if the current directory looks like

           DSC.OLD  bin      cmd      lib      xmpl.c
           DSC.NEW  chaosnet cmtest   mail     xmpl.o
           bench    class    dev      mbox     xmpl.out

     and the input is

           % vi ch<escape>

     csh will complete the prefix ``ch''  to  the  only  matching
file name
     ``chaosnet'', changing the input line to

           % vi chaosnet

     However, given

           % vi D<escape>

     csh will only expand the input to

           % vi DSC.

     and will sound the terminal bell to indicate that the expansion is incomplete,
 since there are two file names  matching  the  prefix

     If  a partial file name is followed by the end-of-file character (usually
     control-D), then, instead of completing the name,  csh  will
list all file
     names matching the prefix.  For example, the input

           % vi D<control-D>

     causes all files beginning with `D' to be listed:

           DSC.NEW   DSC.OLD

     while the input line remains unchanged.

     The  same  system of escape and end-of-file can also be used
to expand partial
 user names, if the word to be completed (or listed) begins with the
     tilde character (`~').  For example, typing

           cd ~ro<escape>

     may produce the expansion

           cd ~root

     The  use  of  the terminal bell to signal errors or multiple
matches can be
     inhibited by setting the variable nobeep.

     Normally, all files in the particular directory  are  candidates for name
     completion.   Files  with  certain  suffixes can be excluded
from consideration
 by setting the variable fignore to the list of suffixes
to be ignored.
  Thus, if fignore is set by the command

           % set fignore = (.o .out)

     then typing

           % vi x<escape>

     would result in the completion to

           % vi xmpl.c

     ignoring the files "xmpl.o" and "xmpl.out".  However, if the
only completion
 possible requires not  ignoring  these  suffixes,  then
they are not ignored.
   In addition, fignore does not affect the listing of
file names by
     control-D.  All files are listed regardless of their suffixes.

   Substitutions    [Toc]    [Back]
     We  now  describe the various transformations the shell performs on the input
 in the order in which they occur.

   History substitutions    [Toc]    [Back]
     History substitutions place words from previous command  input as portions
     of  new  commands, 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
     History substitutions begin with the character `!'  and  may
begin anywhere
     in  the  input  stream  (with  the  proviso that they do not
nest).  This `!'
     may be preceded by a `' to prevent its special meaning;  for
     a `!' character 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.)
  Any input line that contains history  substitution  is
echoed on the
     terminal  before  it is executed as it would have been typed
without history

     Commands input from the terminal that consist of one or more
words are
     saved  on the history list.  The history substitutions reintroduce sequences
 of words from these saved commands  into  the  input
stream.  The
     size  of the history list is controlled by the history variable; the previous
 command is always retained, regardless of the value of
the history
     variable.  Commands are numbered sequentially from 1.

     For  definiteness,  consider  the  following output from the
history command:

            9  write michael
           10  ex write.c
           11  cat oldwrite.c
           12  diff *write.c

     The commands are shown with their event numbers.  It is  not
usually necessary
  to  use  event numbers, but the current event number
can be made
     part of the prompt by placing a `!' in the prompt string.

     With the current event 13 we can refer to previous events by
event number
     `!11', relatively as in `!-2' (referring to the same event),
by a prefix
     of a command word as in `!d' for  event  12  or  `!wri'  for
event 9, or by a
     string contained in a word in the command as in `!?mic?' also referring
     to event 9.  These forms,  without  further  change,  simply
reintroduce the
     words  of  the  specified events, each separated by a single
blank.  As a
     special case, `!!' refers to the previous command; thus `!!'
alone is a

     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 are:

           0       first (command) word
           n       n'th argument
           ^       first argument; i.e., `1'
           $       last argument
           %        word  matched  by (immediately preceding) ?s?
           x-y     range of words
           -y      abbreviates `0-y'
           *       abbreviates `^-$', or nothing if only  1  word
in event
           x*      abbreviates `x-$'
           x-      like `x*' but omitting word `$'

     The  `:'  separating  the  event specification from the word
designator can
     be omitted if the argument selector begins with a `^',  `$',
`*', `-', or
     `%'.  After the optional word designator, a sequence of modifiers can be
     placed, each preceded by a `:'.  The following modifiers are

           h        Remove a trailing pathname component, leaving
the head.
           r       Remove a trailing  `.xxx'  component,  leaving
the root name.
           e       Remove all but the extension `.xxx' part.
           s/l/r/  Substitute l for r.
           t        Remove all leading pathname components, leaving the tail.
           &       Repeat the previous substitution.
           g       Apply the change once on each word,  prefixing
the above;
                   e.g., `g&'.
           a        Apply the change as many times as possible on
a single
                   word, prefixing the above.  It can be used together with
                   `g' to apply a substitution globally.
           p        Print the new command line but do not execute
           q       Quote the substituted words,  preventing  further substitutions.

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

     Unless preceded by a `g' the change is applied only  to  the
first modifiable
  word.   With substitutions, it is an error for no word
to be applicable.

     The left-hand side of substitutions are not regular  expressions in the
     sense  of  the  editors, but instead strings.  Any character
may be used as
     the delimiter in place of `/'; a `' quotes the delimiter into the l and
     r  strings.  The character `&' in the right-hand side is replaced by the
     text from the left.  A `' also quotes `&'.  A NULL l  (`//')
uses the
     previous  string  either from an l or from a contextual scan
string s in
     `!?s     newline follows immediately as may the trailing `?'
in a contextual scan.

     A history reference may be given without an event specification; e.g.,
     `!$'.  Here, the reference is to the previous command unless
a previous
     history  reference  occurred  on the same line in which case
this form repeats
 the previous reference.  Thus ``!?foo?^ !$'' gives the
first and
     last arguments from the command matching ``?foo?''.

     A  special  abbreviation  of a history reference occurs when
the first nonblank
 character of an input line is a `^'.  This is  equivalent to
     ``!:s^''  providing a convenient shorthand for substitutions
on the text
     of the previous line.  Thus ^lb^lib fixes  the  spelling  of
``lib'' in the
     previous  command.   Finally,  a history substitution may be
surrounded with
     `{' and `}' if necessary to insulate it from the  characters
that follow.
     Thus,  after  ls  -ld  ~paul  we might do !{l}a to do ls -ld
~paula, while !la
     would look for a command starting with ``la''.

   Quotations with ' and "
     The quotation of strings by `'' and `"' can be used to  prevent all or
     some  of  the  remaining substitutions.  Strings enclosed in
`'' are prevented
 from any further interpretation.  Strings enclosed in
`"' may be
     expanded as described below.

     In  both cases the resulting text becomes (all or part of) a
single word;
     only in one special case (see  Command  Substitution  below)
does a `"'
     quoted  string yield parts of more than one word; `'' quoted
strings never

   Alias substitution    [Toc]    [Back]
     The shell maintains a list of aliases  that  can  be  established, displayed
     and  modified  by  the  alias and unalias commands.  After a
command line is
     scanned, it is parsed into distinct commands and  the  first
word of each
     command,  left-to-right,  is  checked  to  see  if it has an
alias.  If it
     does, then the text that is the alias for  that  command  is
reread with the
     history  mechanism available as though that command were the
previous input
 line.  The resulting words replace the command and argument list.  If
     no  reference is made to the history list, then the argument
list is left

     Thus if the alias for ``ls'' is ``ls -l'',  the  command  ls
/usr would map
     to  ls  -l  /usr,  the argument list here being undisturbed.
Similarly, if
     the alias for ``lookup'' was ``grep  !^  /etc/passwd''  then
lookup bill
     would map to grep bill /etc/passwd.

     If  an  alias is found, the word transformation of the input
text is performed
 and the aliasing process begins again on the reformed
input line.
     Looping  is  prevented  if the first word of the new text is
the same as the
     old by flagging it to prevent further aliasing.  Other loops
are detected
     and cause an error.

     Note  that  the mechanism allows aliases to introduce parser
     Thus, we can alias print 'pr* | lpr' to make a command  that
pr's its
     arguments to the line printer.

   Variable substitution    [Toc]    [Back]
     The shell maintains a set of variables, each of which has as
value a list
     of zero or more words.  Some of these variables are  set  by
the shell or
     referred  to  by  it.  For instance, the argv variable is an
image of the
     shell's argument list, and words of  this  variable's  value
are referred to
     in special ways.

     The  values of variables may be displayed and changed by using the set and
     unset commands.  Of the variables referred to by the shell a
number are
     toggles;  the  shell does not care what their value is, only
whether they
     are set or not.  For instance, the  verbose  variable  is  a
toggle that
     causes  command  input  to  be  echoed.  The setting of this
variable results
     from the -v command-line option.

     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
     strings.   For  the purposes of numeric operations, the null
string is considered
 to be zero, and the second and additional  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  `$'
     This  expansion can be prevented by preceding the `$' with a
`' except
     within double quotes (`"'),  where  it  always  occurs,  and
within single
     quotes  (`''),  where  it  never  occurs.  Strings quoted by
backticks (` `)
     are interpreted later (see Command substitution  below),  so
`$' substitution
  does not occur there until later, if at all.  A `$' is
passed unchanged
 if followed by a blank, tab, or end-of-line.

     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
     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
     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 that is not set.

                   Are replaced by the  words  of  the  value  of
variable name,
                   each  separated  by  a blank.  Braces insulate
name from following
 characters that 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 here).
                   May be used to select only some of  the  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  number 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.
                   Gives the number of  words  in  the  variable.
This is useful
                   for later use in a ``$argv[selector]''.
           $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[*]''.

     The  modifiers `:e', `:h', `:t', `:r', `:q', and `:x' may be
applied to
     the substitutions above as may `:gh', `:gt', and `:gr'.   If
braces `{'
     `}'  appear  in the command form then the modifiers must appear within the
     braces.  The current implementation allows only one `:' modifier on each
     `$' expansion.

     The  following  substitutions  may  not be modified with `:'
                   Substitutes the string ``1'' if name  is  set,
``0'' if it is
           $?0      Substitutes `1' if the current input filename
is known, `0'
                   if it is not.
           $$      Substitute the (decimal) process number of the
                   shell.  Do NOT use this mechanism for generating temporary
                   file names; see mktemp(1) instead.
           $!      Substitute the (decimal) process number of the
last background
 process started by this shell.
           $<       Substitutes  a  line from the standard input,
with no further
                   interpretation.  It can be used to  read  from
the keyboard
                   in a shell script.

   Command and filename substitution    [Toc]    [Back]
     The  remaining substitutions, command and filename substitution, are applied
 selectively to the arguments of built-in commands.  By
     we mean that portions of expressions which are not evaluated
are not subjected
 to these expansions.  For commands that are  not  internal to the
     shell,  the  command name is substituted separately from the
argument list.
     This occurs very late,  after  input-output  redirection  is
performed, and
     in a child of the main shell.

   Command substitution    [Toc]    [Back]
     Command  substitution is shown by a command enclosed in ``'.
The output
     from such a command is normally broken into  separate  words
at blanks,
     tabs,  and  newlines,  with null words being discarded; this
text then replaces
 the original string.  Within double quotes (`"'), only newlines
     force new words; blanks and tabs are preserved.

     In  any  case, the single final newline does not force a new
word.  Note
     that 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 `~', then that word is  a  candidate  for
filename substitution,
  also  known  as ``globbing''.  This word is then
regarded as a
     pattern, and replaced with an alphabetically sorted list  of
file names
     that match the pattern.  In a list of words specifying filename substitution
 it is an error for no pattern to match an existing file
name, but it
     is  not  required  for  each  pattern  to  match.   Only the
metacharacters `*',
     `?', and `[' imply pattern matching, the characters `~'  and
`{' being
     more akin to abbreviations.

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

     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 variable home.  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
     other than a letter or `/', or does not appear at the beginning of a
     word, it is left undisturbed.

     The  metanotation ``a{b,c,d}e'' is a shorthand for ``abe ace
ade''.  Left
     to right order is preserved, with results of  matches  being
sorted separately
  at  a  low  level to preserve this order.  This construct may be
     nested.  Thus, ``~source/s1/{oldls,ls}.c'' expands to
     ``/usr/source/s1/oldls.c    /usr/source/s1/ls.c''    without
chance of error if
     the home directory for ``source'' is ``/usr/source''.  Similarly
     ``../{memo,*box}''  might   expand   to   ``../memo   ../box
../mbox''.  (Note
     that  ``memo''  was not sorted with the results of the match
to ``*box''.)
     As a special case `{', `}', and `{}' are passed undisturbed.

     The  standard input and the standard output of a command may
be redirected
     with the following syntax:

           < name  Open file name (which is first variable,  command, and filename
 expanded) as the standard input.
           << word
                   Read  the  shell  input  up  to a line that is
identical to
                   word.  word is not subjected to variable, command, or filename
 substitution, and each input line is compared to word
                   before any substitutions are done on the input
line.  Unless
  a quoting `', `"', `'' or ``' appears in
word, variable
 and command substitution is performed  on
the intervening
  lines,  allowing  `' to quote `$', `' and
``'.  Commands
 that are substituted  have  all  blanks,
tabs, and newlines
  preserved, except for the final newline
which is
                   dropped.  The resultant text is placed  in  an
anonymous temporary
  file  that  is given to the command as
its standard
           > name
           >! name
           >& name
           >&! name
                   The file name is used as the standard  output.
If the file
                   does not exist then it is created; if the file
exists, it
                   is truncated; its previous contents are  lost.

                   If  the  variable  noclobber  is set, then the
file must not
                   exist or be a character special file (e.g.,  a
terminal or
                   /dev/null)  or  an  error results.  This helps
prevent accidental
 destruction of files.   Here,  the  `!'
forms can be
                   used to suppress this check.

                   The forms involving `&' route the standard error output into
 the specified file as well as the  standard
output.  name
                   is expanded in the same way as `<' input filenames are.
           >> name
           >>& name
           >>! name
           >>&! name
                   Uses file name as the  standard  output;  like
`>' but places
                   output  at  the end of the file.  If the variable noclobber
                   is set, then it is an error for the  file  not
to exist unless
 one of the `!' forms is given.  Otherwise
similar to

     A command receives the environment in which  the  shell  was
invoked as modified
 by the input-output parameters and the presence of the
command in a
     pipeline.  Thus, unlike some previous shells,  commands  run
from a file of
     shell commands have no access to the text of the commands by
default; instead
 they receive the original standard input of the shell.
The `<<'
     mechanism  should be used to present inline data.  This permits shell command
 scripts to function as components of pipelines and  allows the shell
     to block read its input.  Note that the default standard input for a command
 run detached is not  modified  to  be  the  empty  file
/dev/null; instead
     the standard input remains as the original standard input of
the shell.
     If this is a terminal and if the process  attempts  to  read
from the terminal,
  then the process will block and the user will be notified (see Jobs

     The standard error output may be  directed  through  a  pipe
with the standard
  output.  Simply use the form `|&' instead of just `|'.

   Expressions    [Toc]    [Back]
     Several of the built-in commands  (to  be  described  later)
take expressions,
  in  which  the  operators are similar to those of C,
with the same
     precedence, but with the opposite grouping: right  to  left.
These expressions
  appear  in  the @, exit, if, and while commands.  The
following operators
 are available:

           ||  &&  | ^  &  ==  !=  =~  !~  <=  >= <  > <<  >>   +
-  *  /  %
           !  ~  (  )

     Here  the  precedence increases to the right, `==' `!=' `=~'
and `!~', `<='
     `>=' `<' and `>', `<<' and `>>', `+' and `-',  `*'  `/'  and
`%' being, in
     groups,  at the same level.  The `==' `!=' `=~' and `!~' operators compare
     their arguments as strings; all others operate  on  numbers.
The operators
     `=~'  and  `!~' are like `!=' and `==' except that the right
hand side is a
     pattern  (containing,  e.g.,  *'s,  ?'s,  and  instances  of
``[...]'') against
     which  the  left-hand  operand is matched.  This reduces the
need for use of
     the switch statement in shell scripts when all that is really needed is
     pattern matching.

     Strings  that  begin  with `0' are considered octal numbers.
Null or missing
 arguments are considered `0'.  The results  of  all  expressions are
     strings,  which  represent decimal numbers.  It is important
to note that
     no two components of an expression can appear  in  the  same
word; except
     when  adjacent to components of expressions that are syntactically significant
 to the parser (`&', `|', `<', `>', `(', and `)'), they
should be
     surrounded by spaces.

     Also available in expressions as primitive operands are command executions
 enclosed in `{' and `}' and file enquiries of the form
-l name
     where l is one of:

           r       read access
           w       write access
           x       execute access
           e       existence
           o       ownership
           z       zero size
           f       plain file
           d       directory

     The specified name is command and filename expanded and then
tested to
     see if it has the specified relationship to the  real  user.
If the file
     does  not exist or is inaccessible then all enquiries return
false, i.e.,
     `0'.  Command executions succeed, returning true, i.e., `1',
if the command
  exits  with  status  0, otherwise they fail, returning
false, i.e.,
     `0'.  If more detailed status information is  required  then
the command
     should  be  executed  outside an expression and the variable
status examined.

   Control flow    [Toc]    [Back]
     The shell contains several commands that can be used to regulate the flow
     of  control in command files (shell scripts) and (in limited
but useful
     ways) from terminal input.  These commands  all  operate  by
forcing the
     shell to reread or skip in its input and, because of the implementation,
     restrict the placement of some of the commands.

     The foreach, switch, and while statements, as  well  as  the
     form of the if statement require that the major keywords appear in a single
 simple command on an input line as shown below.

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

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

           alias name
           alias name wordlist
                   The first form prints all aliases.  The second
form prints
                   the  alias  for  name.  The final form assigns
the specified
                   wordlist as the alias  of  name;  wordlist  is
command and
                   filename  substituted.  name is not allowed to
be ``alias''
                   or ``unalias''.

           alloc   Shows the amount of dynamic  memory  acquired,
broken down
                   into  used  and free memory.  With an argument
shows the number
 of free and used blocks in each size category.  The
                   categories  start at size 8 and double at each
step.  This
                   command's output may vary across system types,
since systems
  other  than  the VAX may use a different
memory allocator.

           bg %job ...
                   Puts the current or specified  jobs  into  the
                   continuing them if they were stopped.

           break    Causes  execution  to resume after the end of
the nearest enclosing
 foreach or while.  The remaining  commands on the
                   current line are executed.  Multi-level breaks
are thus
                   possible by writing them all on one line.

                   Causes a break from a switch,  resuming  after
the endsw.

           case label:
                   A label in a switch statement as discussed below.

           cd name
           chdir name
                   Change the shell's working directory to directory name.  If
                   no  argument  is given then change to the home
directory of
                   the user.  If name is not found as a subdirectory of the
                   current  directory  (and  does  not begin with
`/', `./' or
                   `../'), then each component  of  the  variable
cdpath is
                   checked  to see if it has a subdirectory name.
Finally, if
                   all else fails but name is  a  shell  variable
whose value begins
 with `/', then this is tried to see if it
is a directory.

                   Continue execution of  the  nearest  enclosing
while or
                   foreach.  The rest of the commands on the current line are

                   Labels the default case in a switch statement.
The default
                   should come after all case labels.

           dirs     Prints  the  directory  stack; the top of the
stack is at the
                   left, the first directory in the  stack  being
the current

           echo wordlist
           echo -n wordlist
                   The specified words are written to the shell's
                   output, separated by  spaces,  and  terminated
with a newline
                   unless the -n option is specified.

           endsw    See  the  description  of  the  foreach,  if,
switch, and while
                   statements below.

           eval arg ...
                   (As in sh(1).) The arguments are read as input
to the shell
                   and  the  resulting command(s) executed in the
context of the
                   current shell.  This is usually used  to  execute commands
                   generated as the result of command or variable
 since parsing occurs before  these  substitutions.  See
                   tset(1) for an example of using eval.

           exec command
                   The  specified command is executed in place of
the current

           exit (expr)
                   The shell exits either with the value  of  the
status variable
  (first  form)  or  with the value of the
specified expr
                   (second form).

           fg %job ...
                   Brings the current or specified jobs into  the
                   continuing them if they were stopped.

           foreach name (wordlist)
           end      The variable name is successively set to each
member of
                   wordlist and the sequence of commands  between
this command
                   and  the  matching  end  are  executed.  (Both
foreach and end
                   must appear alone  on  separate  lines.)   The
built-in command
                   continue may be used to continue the loop prematurely and
                   the built-in command  break  to  terminate  it
                   When  this  command is read from the terminal,
the loop is
                   read once prompting with `?' before any statements in the
                   loop are executed.  If you make a mistake typing in a loop
                   at the terminal you can rub it out.

           glob wordlist
                   Like echo but no `' escapes are recognized and
words are
                   delimited  by  NUL  characters  in the output.
Useful for programs
 that wish to use the shell  to  filename
expand a list
                   of words.

           goto word
                   The specified word is filename and command expanded to
                   yield a string of the form `label'.  The shell
rewinds its
                   input  as  much as possible and searches for a
line of the
                   form ``label:'', possibly preceded  by  blanks
or tabs.  Execution
 continues after the specified line.

                   Print  a statistics line showing how effective
the internal
                   hash table has been at locating commands  (and
                   exec's).  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

           history n
           history -r n
           history -h n
                   Displays the history event list; if n is  given, only the n
                   most recent events are printed.  The -r option
reverses the
                   order of printout to be most recent first  instead of oldest
                   first.   The -h option causes the history list
to be printed
                   without leading numbers.  This format produces
files suitable
  for  sourcing  using  the  -h  option to

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

           if (expr) then
           else if (expr2) then
           endif    If  the  specified expr is true then the commands up to the
                   first else are executed; otherwise if expr2 is
true then
                   the commands up to the second else are executed, etc.  Any
                   number of else-if pairs are possible; only one
endif is
                   needed.   The  else part is likewise optional.
(The words
                   else and endif must appear at the beginning of
input lines;
                   the  if must appear alone on its input line or
after an

           jobs -l
                   Lists the active jobs;  the  -l  option  lists
process IDs in
                   addition to the normal information.

           kill %job
           kill    [-s signal_name] pid
           kill -sig pid ...
           kill -l [exit_status]
                   Sends either the SIGTERM (terminate) signal or
the specified
 signal to the specified jobs or  processes.  Signals
                   are  either  given  by  number or by names (as
given in
                   <signal.h>, stripped of the  prefix  ``SIG'').
The signal
                   names   are  listed  by  ``kill  -l'';  if  an
exit_status is specified,
 only the corresponding signal name will
be written.
                   There is no default; just saying ``kill'' does
not send a
                   signal to the current job.  If the signal  being sent is
                   SIGTERM  (terminate)  or SIGHUP (hangup), then
the job or
                   process will be sent a SIGCONT (continue) signal as well.

           limit resource
           limit resource maximum-use
           limit -h
           limit -h resource
           limit -h resource maximum-use
                   Limits  the consumption by the current process
and each process
 it creates  to  not  individually  exceed
maximum-use on
                   the  specified resource.  If no maximum-use is
given, then
                   the current limit is printed; if  no  resource
is given, then
                   all  limitations are given.  If the -h flag is
given, the
                   hard limits are used instead  of  the  current
limits.  The
                   hard  limits impose a ceiling on the values of
the current
                   limits.  Only the superuser may raise the hard
limits, but
                   a  user  may lower or raise the current limits
within the legal

                   Resources controllable currently include:

                   cputime       the maximum number  of  CPU-seconds to be used
                                 by each process.

                   filesize       the  largest  single  file  (in
bytes) that can
                                 be created.

                   datasize      the maximum growth  of  the  data+stack region
                                 via  sbrk(2)  beyond  the end of
the program

                   stacksize     the maximum size of the automatically-extended
 stack region.

                   coredumpsize   the  size  of  the largest core
dump (in bytes)
                                 that will be created.

                   memoryuse     the maximum size (in  bytes)  to
which a process's
  resident  set size (RSS)
may grow.

                   memorylocked   The  maximum  size  (in  bytes)
which a process
                                 may  lock  into memory using the
mlock(2) function.

                   maxproc       The maximum number of simultaneous processes
                                 for this user ID.

                   openfiles     The maximum number of simultaneous open files
                                 for this user ID.

                   vmemoryuse    the maximum size (in  bytes)  to
which a process's
 total size may grow.

                   The  maximum-use  may  be given as a (floating
point or integer)
 number followed by a scale  factor.   For
all limits
                   other than cputime the default scale is `k' or
                   ``kilobytes'' (1024 bytes); a scale factor  of
`m' or
                   ``megabytes''  may  also be used.  For cputime
the default
                   scale is ``seconds''; a scale  factor  of  `m'
for minutes or
                   `h' for hours, or a time of the form ``mm:ss''
giving minutes
 and seconds also may be used.

                   For both resource names and scale factors, unambiguous prefixes
 of the names suffice.

           login    Terminate a login shell, replacing it with an
instance of
                   /usr/bin/login.  This is one way to  log  off,
included for
                   compatibility with sh(1).

           logout  Terminate a login shell.  Especially useful if
ignoreeof is

           nice +number
           nice command
           nice +number command
                   The first form sets  the  scheduling  priority
for this shell
                   to  4.   The  second form sets the priority to
the given
                   number.  The final two forms  run  command  at
priority 4 and
                   number  respectively.  The greater the number,
the less CPU
                   the process will get.  The superuser may specify negative
                   priority   by   using  ``nice  -number  ...''.
command is always
                   executed in a sub-shell, and the  restrictions
placed on
                   commands in simple if statements apply.

           nohup command
                   The first form can be used in shell scripts to
                   hangups to be ignored for the remainder of the
script.  The
                   second form causes the specified command to be
run with
                   hangups ignored.  All processes detached  with
`&' are effectively

           notify %job ...
                   Causes  the  shell  to  notify  the user asynchronously when the
                   status  of  the  current  or  specified   jobs
change; normally
                   notification  is  presented  before  a prompt.
This is automatic
 if the shell variable notify is set.

           onintr -
           onintr label
                   Control the action of the shell on interrupts.
The first
                   form  restores the default action of the shell
on interrupts,
 which is to terminate shell scripts  or
to return to
                   the  terminal command input level.  The second
form onintr -
                   causes all interrupts to be ignored.  The  final form causes
                   the  shell to execute a goto label when an interrupt is received
 or a child process  terminates  because
it was interrupted.

                   In  any case, if the shell is running detached
and interrupts
 are being ignored, all forms  of  onintr
have no meaning
  and  interrupts continue to be ignored by
the shell and
                   all invoked commands.  Finally, onintr  statements are ignored
 in the system startup files where interrupts are disabled
 (/etc/csh.cshrc, /etc/csh.login).

           popd +n
                   Pops the directory stack, returning to the new
top directory.
  With an argument ``+n'' discards the n'th
entry in the
                   stack.  The members of the directory stack are
                   from the top starting at 0.

           pushd name
           pushd +n
                   With no arguments, pushd exchanges the top two
elements of
                   the directory stack.  Given a  name  argument,
pushd changes
                   to  the  new directory (ala cd) and pushes the
old current
                   working directory (as in cwd) onto the  directory stack.
                   With  a  numeric  argument,  pushd rotates the
n'th argument of
                   the directory stack around to be the top  element and
                   changes  to  it.  The members of the directory
stack are numbered
 from the top starting at 0.

           rehash  Causes the internal hash table of the contents
of the directories
 in the path variable to be recomputed.  This is
                   needed if new commands are added  to  directories in the path
                   while  you are logged in.  This should only be
necessary if
                   you add commands to one of your  own  directories, or if a
                   systems  programmer  changes the contents of a
system directory.

           repeat count command
                   The specified command, which is subject to the
same restrictions
  as  the command in the one line if
                   above, is executed count times.  I/O  redirections occur exactly
 once, even if count is 0.

           set name
           set name=word
           set name[index]=word
           set name=(wordlist)
                   The  first form of the command shows the value
of all shell
                   variables.  Variables that have other  than  a
single word as
                   their  value  print  as  a  parenthesized word
list.  The second
                   form sets name to the null string.  The  third
form sets
                   name to the single word.  The fourth form sets
the index'th
                   component of name to word; this component must
already exist.
   The final form sets name to the list of
words in
                   wordlist.  The value  is  always  command  and
filename expanded.

                   These  arguments may be repeated to set multiple values in a
                   single set command.  Note however, that  variable expansion
                   happens  for  all arguments before any setting

           setenv name
           setenv name value
                   The first form lists all  current  environment
variables.  It
                   is  equivalent  to printenv(1).  The last form
sets the value
                   of environment variable name to  be  value,  a
single string.
                   The  second form sets name to an empty string.
The most
                   commonly  used  environment  variables   USER,
                   are  automatically  imported  to  and exported
from the csh
                   variables user, term, and path;  there  is  no
need to use
                   setenv for these.

           shift variable
                   The  members  of argv are shifted to the left,
                   argv[1].  It is an error for argv  not  to  be
set or to have
                   less  than one word as value.  The second form
performs the
                   same function on the specified variable.

           source name
           source -h name
                   The shell reads commands  from  name.   source
commands may be
                   nested;  if  they  are  nested  too deeply t

 Similar pages
Name OS Title
csh IRIX shell command interpreter with a C-like syntax
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
csh Tru64 C shell command interpreter
sh FreeBSD command interpreter (shell)
sh Tru64 Shell, the standard command language interpreter
tclsh8.0 Linux Simple shell containing Tcl interpreter
tclsh8.3 Linux Simple shell containing Tcl interpreter
tclsh IRIX Simple shell containing Tcl interpreter
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service