BSD 4_3_Tahoe development

[unix-history] / usr / man / cat1 / limit.0

CSH(1)              UNIX Programmer's Manual               CSH(1)



N\bNA\bAM\bME\bE
    csh - a shell (command interpreter) with C-like syntax

S\bSY\bYN\bNO\bOP\bPS\bSI\bIS\bS
    c\bcs\bsh\bh [ -\b-c\bce\bef\bfi\bin\bns\bst\btv\bvV\bVx\bxX\bX ] [ arg ...  ]

D\bDE\bES\bSC\bCR\bRI\bIP\bPT\bTI\bIO\bON\bN
    _\bC_\bs_\bh is a first implementation of a command language inter-
    preter incorporating a history mechanism (see H\bHi\bis\bst\bto\bor\bry\by S\bSu\bub\bb-\b-
    s\bst\bti\bit\btu\but\bti\bio\bon\bns\bs), job control facilities (see J\bJo\bob\bbs\bs), interactive
    file name and user name completion (see F\bFi\bil\ble\be N\bNa\bam\bme\be C\bCo\bom\bmp\bpl\ble\be-\b-
    t\bti\bio\bon\bn), and a C-like syntax.  So as to be able to use its job
    control facilities, users of _\bc_\bs_\bh must (and automatically)
    use the new tty driver fully described in _\bt_\bt_\by(4).    This new
    tty driver allows generation of interrupt characters from
    the keyboard to tell jobs to stop.  See _\bs_\bt_\bt_\by(1) for details
    on setting options in the new tty driver.

    An instance of _\bc_\bs_\bh begins by executing commands from the
    file `.cshrc' in the _\bh_\bo_\bm_\be directory of the invoker.  If this
    is a login shell then it also executes commands from the
    file `.login' there.  It is typical for users on crt's to
    put the command ``stty crt'' in their ._\bl_\bo_\bg_\bi_\bn file, and to
    also invoke _\bt_\bs_\be_\bt(1) there.

    In the normal case, the shell will then begin reading com-
    mands from the terminal, prompting with `% '.  Processing of
    arguments and the use of the shell to process files contain-
    ing command scripts will be described later.

    The shell then repeatedly performs the following actions: a
    line of command input is read and broken into _\bw_\bo_\br_\bd_\bs.  This
    sequence of words is placed on the command history list and
    then parsed.  Finally each command in the current line is
    executed.

    When a login shell terminates it executes commands from the
    file `.logout' in the users home directory.

    L\bLe\bex\bxi\bic\bca\bal\bl s\bst\btr\bru\buc\bct\btu\bur\bre\be

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

    In addition strings enclosed in matched pairs of quotations,
    `'', ``' or `"', form parts of a word; metacharacters in
    these strings, including blanks and tabs, do not form



Printed 7/9/88           April 24, 1988                         1






CSH(1)              UNIX Programmer's Manual               CSH(1)



    separate words.  These quotations have semantics to be
    described subsequently.  Within pairs of `'' or `"' charac-
    ters a newline preceded by a `\' gives a true newline char-
    acter.

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

    C\bCo\bom\bmm\bma\ban\bnd\bds\bs

    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.  Sequences of pipe-
    lines may be separated by `;', and are then executed sequen-
    tially.  A sequence of pipelines may be executed without
    immediately waiting for it to terminate by following it with
    an `&'.

    Any of the above may be placed in `(' `)' to form a simple
    command (which may be a component of a pipeline, etc.) It is
    also possible to separate pipelines with `||' or `&&' indi-
    cating, as in the C language, that the second is to be exe-
    cuted only if the first fails or succeeds respectively. (See
    _\bE_\bx_\bp_\br_\be_\bs_\bs_\bi_\bo_\bn_\bs.)

    J\bJo\bob\bbs\bs

    The shell associates a _\bj_\bo_\bb with each pipeline.  It keeps a
    table of current jobs, printed by the _\bj_\bo_\bb_\bs command, and
    assigns them small integer numbers.  When a job is started
    asynchronously with `&', the shell prints a line which looks
    like:

         [1] 1234

    indicating 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 the key ^\b^Z\bZ (control-Z) which sends a STOP signal to
    the current job.  The shell will then normally indicate 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 _\bb_\bg command, or run some other commands
    and then eventually bring the job back into the foreground
    with the foreground command _\bf_\bg.  A ^\b^Z\bZ takes effect immedi-
    ately and is like an interrupt in that pending output and



Printed 7/9/88           April 24, 1988                         2






CSH(1)              UNIX Programmer's Manual               CSH(1)



    unread input are discarded when it is typed.  There is
    another special key ^\b^Y\bY which does not generate a STOP signal
    until a program attempts to _\br_\be_\ba_\bd(2) it.  This can usefully
    be typed ahead when you have prepared some commands for a
    job which 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 giv-
    ing the command ``stty tostop''.  If you set this tty
    option, then background jobs will stop when they try to pro-
    duce 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 1 back into the foreground.  Similarly
    saying `%1 &' resumes job 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 suspended _\be_\bx(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 _\bs_\bt_\br_\bi_\bn_\bg, if there is only one such job.

    The shell maintains a notion of the current and previous
    jobs.  In output pertaining to 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 _\bh_\bi_\bs_\bt_\bo_\br_\by mechanism (described below), `%%' is also a
    synonym for the current job.

    S\bSt\bta\bat\btu\bus\bs r\bre\bep\bpo\bor\brt\bti\bin\bng\bg

    This shell learns immediately whenever a process changes
    state.  It normally informs you whenever a job becomes
    blocked so that no further 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 _\bn_\bo_\bt_\bi_\bf_\by, the shell will notify you immedi-
    ately of changes of status in background jobs.  There is
    also a shell command _\bn_\bo_\bt_\bi_\bf_\by which marks a single process so
    that its status changes will be immediately reported.  By
    default _\bn_\bo_\bt_\bi_\bf_\by 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 _\bj_\bo_\bb_\bs command to see what they are.  If you do this or
    immediately try to exit again, the shell will not warn you a



Printed 7/9/88           April 24, 1988                         3






CSH(1)              UNIX Programmer's Manual               CSH(1)



    second time, and the suspended jobs will be terminated.

    F\bFi\bil\ble\be N\bNa\bam\bme\be C\bCo\bom\bmp\bpl\ble\bet\bti\bio\bon\bn

    When the file name completion feature is enabled by setting
    the shell variable _\bf_\bi_\bl_\be_\bc (see s\bse\bet\bt), _\bc_\bs_\bh will interactively
    complete file names and user names from unique prefixes,
    when they are input from the terminal 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>
    _\bc_\bs_\bh will complete the prefix ``ch'' to the only matching
    file name ``chaosnet'', changing the input line to
              % vi chaosnet
    However, given
              % vi D<escape>
    _\bc_\bs_\bh will only expand the input to
              % vi DSC.
    and will sound the terminal bell to indicate that the expan-
    sion is incomplete, since there are two file names matching
    the prefix ``D''.

    If a partial file name is followed by the end-of-file char-
    acter (usually control-D), then, instead of completing the
    name, _\bc_\bs_\bh 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 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 _\bn_\bo_\bb_\be_\be_\bp.

    Normally, all files in the particular directory are candi-
    dates for name completion.  Files with certain suffixes can
    be excluded from consideration by setting the variable _\bf_\bi_\bg_\b-
    _\bn_\bo_\br_\be to the list of suffixes to be ignored.  Thus, if _\bf_\bi_\bg_\b-
    _\bn_\bo_\br_\be is set by the command
              % set fignore = (.o .out)



Printed 7/9/88           April 24, 1988                         4






CSH(1)              UNIX Programmer's Manual               CSH(1)



    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 suf-
    fixes, then they are not ignored.  In addition, _\bf_\bi_\bg_\bn_\bo_\br_\be does
    not affect the listing of file names by control-D.  All
    files are listed regardless of their suffixes.

    S\bSu\bub\bbs\bst\bti\bit\btu\but\bti\bio\bon\bns\bs

    We now describe the various transformations the shell per-
    forms on the input in the order in which they occur.

    H\bHi\bis\bst\bto\bor\bry\by s\bsu\bub\bbs\bst\bti\bit\btu\but\bti\bio\bon\bns\bs

    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 confidence.
    History substitutions begin with the character `!' and may
    begin a\ban\bny\byw\bwh\bhe\ber\bre\be in the input stream (with the proviso that
    they d\bdo\bo n\bno\bot\bt nest.) This `!' may be preceded by an `\' to
    prevent its special meaning; for convenience, a `!' is
    passed unchanged when it is followed by a blank, tab, new-
    line, `=' or `('.  (History substitutions also occur when an
    input line begins with `^'.  This special abbreviation will
    be described later.) Any input line which contains history
    substitution is echoed on the terminal before it is executed
    as it could have been typed without history substitution.

    Commands input from the terminal which consist of one or
    more words are saved on the history list.  The history sub-
    stitutions reintroduce sequences of words from these saved
    commands into the input stream.  The size of which is con-
    trolled by the _\bh_\bi_\bs_\bt_\bo_\br_\by variable; the previous command is
    always retained, regardless of its value.  Commands are num-
    bered sequentially from 1.

    For definiteness, consider the following output from the
    _\bh_\bi_\bs_\bt_\bo_\br_\by 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 _\bp_\br_\bo_\bm_\bp_\bt by placing an



Printed 7/9/88           April 24, 1988                         5






CSH(1)              UNIX Programmer's Manual               CSH(1)



    `!' 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 modification, simply rein-
    troduce the words of the specified events, each separated by
    a single blank.  As a special case `!!' refers to the previ-
    ous command; thus `!!' alone is essentially a _\br_\be_\bd_\bo.

    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
         _\bn    _\bn'th argument
         ^    first argument,  i.e. `1'
         $    last argument
         %    word matched by (immediately preceding) ?_\bs? search
         _\bx-_\by  range of words
         -_\by   abbreviates `0-_\by'
         *    abbreviates `^-$', or nothing if only 1 word in event
         _\bx*   abbreviates `_\bx-$'
         _\bx-   like `_\bx*' 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 can be placed a sequence of modifiers, each pre-
    ceded by a `:'.  The following modifiers are defined:

         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/_\bl/_\br/ Substitute _\bl for _\br
         t      Remove all leading pathname components, leaving the tail.
         &      Repeat the previous substitution.
         g      Apply the change globally, prefixing the above, e.g. `g&'.
         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.

    Unless preceded by a `g' the modification 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 expres-
    sions in the sense of the editors, but rather strings.  Any



Printed 7/9/88           April 24, 1988                         6






CSH(1)              UNIX Programmer's Manual               CSH(1)



    character may be used as the delimiter in place of `/'; a
    `\' quotes the delimiter into the _\bl and _\br strings.  The
    character `&' in the right hand side is replaced by the text
    from the left.  A `\' quotes `&' also.  A null _\bl uses the
    previous string either from a _\bl or from a contextual scan
    string _\bs in `!?_\bs?'.  The trailing delimiter in the substitu-
    tion may be omitted if a newline follows immediately as may
    the trailing `?' in a contextual scan.

    A history reference may be given without an event specifica-
    tion, e.g. `!$'.  In this case the reference is to the pre-
    vious command unless a previous history reference occurred
    on the same line in which case this form repeats the previ-
    ous 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 non-blank character of an input line is a `^'.
    This is equivalent to `!:s^' providing a convenient short-
    hand 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 char-
    acters which follow.  Thus, after `ls -ld ~paul' we might do
    `!{l}a' to do `ls -ld ~paula', while `!la' would look for a
    command starting `la'.

    Q\bQu\buo\bot\bta\bat\bti\bio\bon\bns\bs w\bwi\bit\bth\bh '\b' a\ban\bnd\bd "\b"

    The quotation of strings by `'' and `"' can be used to
    prevent all or some of the remaining substitutions.  Strings
    enclosed in `'' are prevented 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 _\bC_\bo_\bm_\bm_\ba_\bn_\bd _\bS_\bu_\bb_\bs_\bt_\bi_\bt_\bi_\b-
    _\bt_\bi_\bo_\bn below) does a `"' quoted string yield parts of more
    than one word; `'' quoted strings never do.

    A\bAl\bli\bia\bas\bs s\bsu\bub\bbs\bst\bti\bit\btu\but\bti\bio\bon\bn

    The shell maintains a list of aliases which can be esta-
    blished, displayed and modified by the _\ba_\bl_\bi_\ba_\bs and _\bu_\bn_\ba_\bl_\bi_\ba_\bs
    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 which 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
    unchanged.



Printed 7/9/88           April 24, 1988                         7






CSH(1)              UNIX Programmer's Manual               CSH(1)



    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
    metasyntax.  Thus we can `alias print 'pr \!* | lpr'' to
    make a command which _\bp_\br'_\bs its arguments to the line printer.

    V\bVa\bar\bri\bia\bab\bbl\ble\be s\bsu\bub\bbs\bst\bti\bit\btu\but\bti\bio\bon\bn

    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 _\ba_\br_\bg_\bv variable is an image of the shell's argument list,
    and words of this variable's value are referred to in spe-
    cial ways.

    The values of variables may be displayed and changed by
    using the _\bs_\be_\bt and _\bu_\bn_\bs_\be_\bt 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 _\bv_\be_\br_\bb_\bo_\bs_\be variable is a toggle which causes
    command input to be echoed.  The setting of this variable
    results from the -\b-v\bv command line option.

    Other operations treat variables numerically.  The `@' com-
    mand permits numeric calculations to be performed and the
    result assigned to a variable.  Variable values are, how-
    ever, always represented as (zero or more) strings.  For the
    purposes of numeric operations, the null string is con-
    sidered 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
    a\bal\blw\bwa\bay\bys\bs occurs, and within `''s where it n\bne\bev\bve\ber\br occurs.
    Strings quoted by ``' are interpreted later (see _\bC_\bo_\bm_\bm_\ba_\bn_\bd
    _\bs_\bu_\bb_\bs_\bt_\bi_\bt_\bu_\bt_\bi_\bo_\bn below) so `$' substitution does not occur there
    until later, if at all.  A `$' is passed unchanged if fol-
    lowed by a blank, tab, or end-of-line.




Printed 7/9/88           April 24, 1988                         8






CSH(1)              UNIX Programmer's Manual               CSH(1)



    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 variables value separated
    by blanks.  When the `:q' modifier is applied to a substitu-
    tion the variable will expand to multiple words with each
    word separated by a blank and quoted to prevent later com-
    mand 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
    ${name}
         Are replaced by the words of the value of variable
         _\bn_\ba_\bm_\be, each separated by a blank.  Braces insulate _\bn_\ba_\bm_\be
         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 _\bn_\ba_\bm_\be is not a shell variable, but is set in the
         environment, then that value is returned (but :\b: modif-
         iers and the other forms given below are not available
         in this case).

    $name[selector]
    ${name[selector]}
         May be used to select only some of the words from the
         value of _\bn_\ba_\bm_\be. The selector is subjected to `$' substi-
         tution and may consist of a single number or two
         numbers separated by a `-'.  The first word of a vari-
         ables 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 omit-
         ted or in range.

    $#name
    ${#name}
         Gives the number of words in the variable.  This is
         useful for later use in a `[selector]'.



Printed 7/9/88           April 24, 1988                         9






CSH(1)              UNIX Programmer's Manual               CSH(1)



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

    $number
    ${number}
         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.  T\bTh\bhe\be c\bcu\bur\brr\bre\ben\bnt\bt
    i\bim\bmp\bpl\ble\bem\bme\ben\bnt\bta\bat\bti\bio\bon\bn a\bal\bll\blo\bow\bws\bs o\bon\bnl\bly\by o\bon\bne\be `\b`:\b:'\b' m\bmo\bod\bdi\bif\bfi\bie\ber\br o\bon\bn e\bea\bac\bch\bh `\b`$\b$'\b'
    e\bex\bxp\bpa\ban\bns\bsi\bio\bon\bn.\b.

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

    $?name
    ${?name}
         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.

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

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

    C\bCo\bom\bmm\bma\ban\bnd\bd a\ban\bnd\bd f\bfi\bil\ble\ben\bna\bam\bme\be s\bsu\bub\bbs\bst\bti\bit\btu\but\bti\bio\bon\bn

    The remaining substitutions, command and filename substitu-
    tion, 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 input-output redirection is per-
    formed, and in a child of the main shell.





Printed 7/9/88           April 24, 1988                        10






CSH(1)              UNIX Programmer's Manual               CSH(1)



    C\bCo\bom\bmm\bma\ban\bnd\bd s\bsu\bub\bbs\bst\bti\bit\btu\but\bti\bio\bon\bn

    Command substitution is indicated 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 replacing the original
    string.  Within `"'s, 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 substitu-
    tion to yield only part of a word, even if the command out-
    puts a complete line.

    F\bFi\bil\ble\ben\bna\bam\bme\be s\bsu\bub\bbs\bst\bti\bit\btu\but\bti\bio\bon\bn

    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 `glob-
    bing'.  This word is then regarded as a pattern, and
    replaced with an alphabetically sorted list of file names
    which 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 pat-
    tern 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 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.

    The character `~' at the beginning of a filename is used to
    refer to home directories.  Standing alone, i.e. `~' it
    expands to the invokers home directory as reflected in the
    value of the variable _\bh_\bo_\bm_\be. When followed by a name consist-
    ing of letters, digits and `-' characters the shell searches
    for a user with that name and substitutes their home direc-
    tory;  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 not at the beginning of a word, it is left undis-
    turbed.

    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



Printed 7/9/88           April 24, 1988                        11






CSH(1)              UNIX Programmer's Manual               CSH(1)



    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' whether or not these files exist
    without any 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 matching `*box'.) As a spe-
    cial case `{', `}' and `{}' are passed undisturbed.

    I\bIn\bnp\bpu\but\bt/\b/o\bou\but\btp\bpu\but\bt

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

    < name
         Open file _\bn_\ba_\bm_\be (which is first variable, command and
         filename expanded) as the standard input.

    << word
         Read the shell input up to a line which is identical to
         _\bw_\bo_\br_\bd. _\bW_\bo_\br_\bd is not subjected to variable, filename or
         command substitution, and each input line is compared
         to _\bw_\bo_\br_\bd before any substitutions are done on this input
         line.  Unless a quoting `\', `"', `'' or ``' appears in
         _\bw_\bo_\br_\bd variable and command substitution is performed on
         the intervening lines, allowing `\' to quote `$', `\'
         and ``'.  Commands which 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 which is given to
         the command as standard input.

    > name
    >! name
    >& name
    >&! name
         The file _\bn_\ba_\bm_\be is used as standard output.  If the file
         does not exist then it is created; if the file exists,
         its is truncated, its previous contents being lost.

         If the variable _\bn_\bo_\bc_\bl_\bo_\bb_\bb_\be_\br is set, then the file must
         not exist or be a character special file (e.g. a termi-
         nal or `/dev/null') or an error results.  This helps
         prevent accidental destruction of files.  In this case
         the `!' forms can be used and suppress this check.

         The forms involving `&' route the diagnostic output
         into the specified file as well as the standard output.
         _\bN_\ba_\bm_\be is expanded in the same way as `<' input filenames
         are.





Printed 7/9/88           April 24, 1988                        12






CSH(1)              UNIX Programmer's Manual               CSH(1)



    >> name
    >>& name
    >>! name
    >>&! name
         Uses file _\bn_\ba_\bm_\be as standard output like `>' but places
         output at the end of the file.  If the variable
         _\bn_\bo_\bc_\bl_\bo_\bb_\bb_\be_\br is set, then it is an error for the file not
         to exist unless one of the `!' forms is given.  Other-
         wise 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;
    rather 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 com-
    mand run detached is n\bno\bot\bt modified to be the empty file
    `/dev/null'; rather the standard input remains as the origi-
    nal 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 J\bJo\bob\bbs\bs
    above).

    Diagnostic output may be directed through a pipe with the
    standard output.  Simply use the form `|&' rather than just
    `|'.

    E\bEx\bxp\bpr\bre\bes\bss\bsi\bio\bon\bns\bs

    A number of the builtin commands (to be described subse-
    quently) take expressions, in which the operators are simi-
    lar to those of C, with the same precedence.  These expres-
    sions appear in the @, _\be_\bx_\bi_\bt, _\bi_\bf, and _\bw_\bh_\bi_\bl_\be 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 _\bp_\ba_\bt_\bt_\be_\br_\bn (containing, e.g. `*'s, `?'s and instances
    of `[...]') against which the left hand operand is matched.
    This reduces the need for use of the _\bs_\bw_\bi_\bt_\bc_\bh statement in
    shell scripts when all that is really needed is pattern



Printed 7/9/88           April 24, 1988                        13






CSH(1)              UNIX Programmer's Manual               CSH(1)



    matching.

    Strings which begin with `0' are considered octal numbers.
    Null or missing arguments are considered `0'.  The result 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 adja-
    cent to components of expressions which are syntactically
    significant to the parser (`&' `|' `<' `>' `(' `)') they
    should be surrounded by spaces.

    Also available in expressions as primitive operands are com-
    mand executions enclosed in `{' and `}' and file enquiries
    of the form `-_\bl  name' where _\bl 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 execu-
    tions 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 of an expression
    and the variable _\bs_\bt_\ba_\bt_\bu_\bs examined.

    C\bCo\bon\bnt\btr\bro\bol\bl f\bfl\blo\bow\bw

    The shell contains a number of commands which 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, due to the implementation,
    restrict the placement of some of the commands.

    The _\bf_\bo_\br_\be_\ba_\bc_\bh, _\bs_\bw_\bi_\bt_\bc_\bh, and _\bw_\bh_\bi_\bl_\be statements, as well as the
    _\bi_\bf-_\bt_\bh_\be_\bn-_\be_\bl_\bs_\be form of the _\bi_\bf 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



Printed 7/9/88           April 24, 1988                        14






CSH(1)              UNIX Programmer's Manual               CSH(1)



    will succeed on non-seekable inputs.)

    B\bBu\bui\bil\blt\bti\bin\bn c\bco\bom\bmm\bma\ban\bnd\bds\bs

    Builtin commands are executed within the shell.  If a buil-
    tin command occurs as any component of a pipeline except the
    last then it is executed in a subshell.

    a\bal\bli\bia\bas\bs
    a\bal\bli\bia\bas\bs name
    a\bal\bli\bia\bas\bs name wordlist
         The first form prints all aliases.  The second form
         prints the alias for name.  The final form assigns the
         specified _\bw_\bo_\br_\bd_\bl_\bi_\bs_\bt as the alias of _\bn_\ba_\bm_\be; _\bw_\bo_\br_\bd_\bl_\bi_\bs_\bt is
         command and filename substituted.  _\bN_\ba_\bm_\be is not allowed
         to be _\ba_\bl_\bi_\ba_\bs or _\bu_\bn_\ba_\bl_\bi_\ba_\bs.

    a\bal\bll\blo\boc\bc
         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 sys-
         tem types, since systems other than the VAX may use a
         different memory allocator.

    b\bbg\bg
    b\bbg\bg %\b%job ...
         Puts the current or specified jobs into the background,
         continuing them if they were stopped.

    b\bbr\bre\bea\bak\bk
         Causes execution to resume after the _\be_\bn_\bd of the nearest
         enclosing _\bf_\bo_\br_\be_\ba_\bc_\bh or _\bw_\bh_\bi_\bl_\be. The remaining commands on
         the current line are executed.  Multi-level breaks are
         thus possible by writing them all on one line.

    b\bbr\bre\bea\bak\bks\bsw\bw
         Causes a break from a _\bs_\bw_\bi_\bt_\bc_\bh, resuming after the _\be_\bn_\bd_\bs_\bw.

    c\bca\bas\bse\be label:
         A label in a _\bs_\bw_\bi_\bt_\bc_\bh statement as discussed below.

    c\bcd\bd
    c\bcd\bd name
    c\bch\bhd\bdi\bir\br
    c\bch\bhd\bdi\bir\br name
         Change the shell's working directory to directory _\bn_\ba_\bm_\be.
         If no argument is given then change to the home direc-
         tory of the user.
         If _\bn_\ba_\bm_\be is not found as a subdirectory of the current
         directory (and does not begin with `/', `./' or `../'),



Printed 7/9/88           April 24, 1988                        15






CSH(1)              UNIX Programmer's Manual               CSH(1)



         then each component of the variable _\bc_\bd_\bp_\ba_\bt_\bh is checked
         to see if it has a subdirectory _\bn_\ba_\bm_\be. Finally, if all
         else fails but _\bn_\ba_\bm_\be is a shell variable whose value
         begins with `/', then this is tried to see if it is a
         directory.

    c\bco\bon\bnt\bti\bin\bnu\bue\be
         Continue execution of the nearest enclosing _\bw_\bh_\bi_\bl_\be or
         _\bf_\bo_\br_\be_\ba_\bc_\bh. The rest of the commands on the current line
         are executed.

    d\bde\bef\bfa\bau\bul\blt\bt:\b:
         Labels the default case in a _\bs_\bw_\bi_\bt_\bc_\bh statement.  The
         default should come after all _\bc_\ba_\bs_\be labels.

    d\bdi\bir\brs\bs
         Prints the directory stack; the top of the stack is at
         the left, the first directory in the stack being the
         current directory.

    e\bec\bch\bho\bo wordlist
    e\bec\bch\bho\bo -\b-n\bn wordlist
         The specified words are written to the shells standard
         output, separated by spaces, and terminated with a new-
         line unless the -\b-n\bn option is specified.

    e\bel\bls\bse\be
    e\ben\bnd\bd
    e\ben\bnd\bdi\bif\bf
    e\ben\bnd\bds\bsw\bw
         See the description of the _\bf_\bo_\br_\be_\ba_\bc_\bh, _\bi_\bf, _\bs_\bw_\bi_\bt_\bc_\bh, and
         _\bw_\bh_\bi_\bl_\be statements below.

    e\bev\bva\bal\bl arg ...
         (As in _\bs_\bh(1).) The arguments are read as input to the
         shell and the resulting command(s) executed in the con-
         text of the current shell.  This is usually used to
         execute commands generated as the result of command or
         variable substitution, since parsing occurs before
         these substitutions.  See _\bt_\bs_\be_\bt(1) for an example of
         using _\be_\bv_\ba_\bl.

    e\bex\bxe\bec\bc command
         The specified command is executed in place of the
         current shell.

    e\bex\bxi\bit\bt
    e\bex\bxi\bit\bt(expr)
         The shell exits either with the value of the _\bs_\bt_\ba_\bt_\bu_\bs
         variable (first form) or with the value of the speci-
         fied _\be_\bx_\bp_\br (second form).




Printed 7/9/88           April 24, 1988                        16






CSH(1)              UNIX Programmer's Manual               CSH(1)



    f\bfg\bg
    f\bfg\bg %\b%job ...
         Brings the current or specified jobs into the fore-
         ground, continuing them if they were stopped.

    f\bfo\bor\bre\bea\bac\bch\bh name (wordlist)
        ...
    e\ben\bnd\bd
         The variable _\bn_\ba_\bm_\be is successively set to each member of
         _\bw_\bo_\br_\bd_\bl_\bi_\bs_\bt and the sequence of commands between this com-
         mand and the matching _\be_\bn_\bd are executed.  (Both _\bf_\bo_\br_\be_\ba_\bc_\bh
         and _\be_\bn_\bd must appear alone on separate lines.)

         The builtin command _\bc_\bo_\bn_\bt_\bi_\bn_\bu_\be may be used to continue
         the loop prematurely and the builtin command _\bb_\br_\be_\ba_\bk to
         terminate it prematurely.  When this command is read
         from the terminal, the loop is read up once prompting
         with `?' before any statements in the loop are exe-
         cuted.  If you make a mistake typing in a loop at the
         terminal you can rub it out.

    g\bgl\blo\bob\bb wordlist
         Like _\be_\bc_\bh_\bo but no `\' escapes are recognized and words
         are delimited by null characters in the output.  Useful
         for programs which wish to use the shell to filename
         expand a list of words.

    g\bgo\bot\bto\bo word
         The specified _\bw_\bo_\br_\bd 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.

    h\bha\bas\bsh\bhs\bst\bta\bat\bt
         Print a statistics line indicating how effective the
         internal hash table has been at locating commands (and
         avoiding _\be_\bx_\be_\bc's).  An _\be_\bx_\be_\bc is attempted for each com-
         ponent of the _\bp_\ba_\bt_\bh where the hash function indicates a
         possible hit, and in each component which does not
         begin with a `/'.

    h\bhi\bis\bst\bto\bor\bry\by
    h\bhi\bis\bst\bto\bor\bry\by _\bn
    h\bhi\bis\bst\bto\bor\bry\by -\b-r\br _\bn
    h\bhi\bis\bst\bto\bor\bry\by -\b-h\bh _\bn
         Displays the history event list; if _\bn is given only the
         _\bn most recent events are printed.  The -\b-r\br option rev-
         erses the order of printout to be most recent first
         rather than oldest first.  The -\b-h\bh option causes the
         history list to be printed without leading numbers.
         This is used to produce files suitable for sourceing



Printed 7/9/88           April 24, 1988                        17






CSH(1)              UNIX Programmer's Manual               CSH(1)



         using the -h option to _\bs_\bo_\bu_\br_\bc_\be.

    i\bif\bf (expr) command
         If the specified expression evaluates true, then the
         single _\bc_\bo_\bm_\bm_\ba_\bn_\bd with arguments is executed.  Variable
         substitution on _\bc_\bo_\bm_\bm_\ba_\bn_\bd happens early, at the same time
         it does for the rest of the _\bi_\bf command.  _\bC_\bo_\bm_\bm_\ba_\bn_\bd must
         be a simple command, not a pipeline, a command list, or
         a parenthesized command list.  Input/output redirection
         occurs even if _\be_\bx_\bp_\br is false, when command is n\bno\bot\bt exe-
         cuted (this is a bug).

    i\bif\bf (expr) t\bth\bhe\ben\bn
        ...
    e\bel\bls\bse\be i\bif\bf (expr2) t\bth\bhe\ben\bn
        ...
    e\bel\bls\bse\be
        ...
    e\ben\bnd\bdi\bif\bf
         If the specified _\be_\bx_\bp_\br is true then the commands to the
         first _\be_\bl_\bs_\be are executed; otherwise if _\be_\bx_\bp_\br_\b2 is true
         then the commands to the second _\be_\bl_\bs_\be are executed, etc.
         Any number of _\be_\bl_\bs_\be-_\bi_\bf pairs are possible; only one
         _\be_\bn_\bd_\bi_\bf is needed.  The _\be_\bl_\bs_\be part is likewise optional.
         (The words _\be_\bl_\bs_\be and _\be_\bn_\bd_\bi_\bf must appear at the beginning
         of input lines; the _\bi_\bf must appear alone on its input
         line or after an _\be_\bl_\bs_\be.)

    j\bjo\bob\bbs\bs
    j\bjo\bob\bbs\bs -\b-l\bl
         Lists the active jobs; given the -\b-l\bl options lists pro-
         cess id's in addition to the normal information.

    k\bki\bil\bll\bl %\b%job
    k\bki\bil\bll\bl -\b-sig %\b%job ...
    k\bki\bil\bll\bl pid
    k\bki\bil\bll\bl -\b-sig pid ...
    k\bki\bil\bll\bl -\b-l\bl
         Sends either the TERM (terminate) signal or the speci-
         fied signal to the specified jobs or processes.  Sig-
         nals are either given by number or by names (as given
         in /_\bu_\bs_\br/_\bi_\bn_\bc_\bl_\bu_\bd_\be/_\bs_\bi_\bg_\bn_\ba_\bl._\bh, stripped of the prefix
         ``SIG'').  The signal names are listed by ``kill -l''.
         There is no default, saying just `kill' does not send a
         signal to the current job.  If the signal being sent is
         TERM (terminate) or HUP (hangup), then the job or pro-
         cess will be sent a CONT (continue) signal as well.

    l\bli\bim\bmi\bit\bt
    l\bli\bim\bmi\bit\bt _\br_\be_\bs_\bo_\bu_\br_\bc_\be
    l\bli\bim\bmi\bit\bt _\br_\be_\bs_\bo_\bu_\br_\bc_\be _\bm_\ba_\bx_\bi_\bm_\bu_\bm-_\bu_\bs_\be




Printed 7/9/88           April 24, 1988                        18






CSH(1)              UNIX Programmer's Manual               CSH(1)



    l\bli\bim\bmi\bit\bt -\b-h\bh
    l\bli\bim\bmi\bit\bt -\b-h\bh _\br_\be_\bs_\bo_\bu_\br_\bc_\be
    l\bli\bim\bmi\bit\bt -\b-h\bh _\br_\be_\bs_\bo_\bu_\br_\bc_\be _\bm_\ba_\bx_\bi_\bm_\bu_\bm-_\bu_\bs_\be
         Limits the consumption by the current process and each
         process it creates to not individually exceed _\bm_\ba_\bx_\bi_\bm_\bu_\bm-
         _\bu_\bs_\be on the specified _\br_\be_\bs_\bo_\bu_\br_\bc_\be.  If no _\bm_\ba_\bx_\bi_\bm_\bu_\bm-_\bu_\bs_\be is
         given, then the current limit is printed; if no
         _\br_\be_\bs_\bo_\bu_\br_\bc_\be is given, then all limitations are given.  If
         the -\b-h\bh flag is given, the hard limits are used instead
         of the current limits.  The hard limits impose a ceil-
         ing on the values of the current limits.  Only the
         super-user may raise the hard limits, but a user may
         lower or raise the current limits within the legal
         range.

         Resources controllable currently include _\bc_\bp_\bu_\bt_\bi_\bm_\be (the
         maximum number of cpu-seconds to be used by each pro-
         cess), _\bf_\bi_\bl_\be_\bs_\bi_\bz_\be (the largest single file which can be
         created), _\bd_\ba_\bt_\ba_\bs_\bi_\bz_\be (the maximum growth of the
         data+stack region via _\bs_\bb_\br_\bk(2) beyond the end of the
         program text), _\bs_\bt_\ba_\bc_\bk_\bs_\bi_\bz_\be (the maximum size of the
         automatically-extended stack region), and _\bc_\bo_\br_\be_\bd_\bu_\bm_\bp_\bs_\bi_\bz_\be
         (the size of the largest core dump that will be
         created).

         The _\bm_\ba_\bx_\bi_\bm_\bu_\bm-_\bu_\bs_\be may be given as a (floating point or
         integer) number followed by a scale factor.  For all
         limits other than _\bc_\bp_\bu_\bt_\bi_\bm_\be the default scale is `k' or
         `kilobytes' (1024 bytes); a scale factor of `m' or
         `megabytes' may also be used.  For _\bc_\bp_\bu_\bt_\bi_\bm_\be the default
         scaling is `seconds', while `m' for minutes or `h' for
         hours, or a time of the form `mm:ss' giving minutes and
         seconds may be used.

         For both _\br_\be_\bs_\bo_\bu_\br_\bc_\be names and scale factors, unambiguous
         prefixes of the names suffice.

    l\blo\bog\bgi\bin\bn
         Terminate a login shell, replacing it with an instance
         of /\b/b\bbi\bin\bn/\b/l\blo\bog\bgi\bin\bn.\b. This is one way to log off, included for
         compatibility with _\bs_\bh(1).

    l\blo\bog\bgo\bou\but\bt
         Terminate a login shell.  Especially useful if
         _\bi_\bg_\bn_\bo_\br_\be_\be_\bo_\bf is set.

    n\bni\bic\bce\be
    n\bni\bic\bce\be +number
    n\bni\bic\bce\be command
    n\bni\bic\bce\be +number command
         The first form sets the scheduling priority for this
         shell to 4.  The second form sets the priority to the



Printed 7/9/88           April 24, 1988                        19






CSH(1)              UNIX Programmer's Manual               CSH(1)



         given number.  The final two forms run command at
         priority 4 and _\bn_\bu_\bm_\bb_\be_\br respectively.  The greater the
         number, the less cpu the process will get.  The super-
         user may specify negative priority by using `nice
         -number ...'.  Command is always executed in a sub-
         shell, and the restrictions placed on commands in sim-
         ple _\bi_\bf statements apply.

    n\bno\boh\bhu\bup\bp
    n\bno\boh\bhu\bup\bp command
         The first form can be used in shell scripts to cause
         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 _\bn_\bo_\bh_\bu_\bp'_\be_\bd.

    n\bno\bot\bti\bif\bfy\by
    n\bno\bot\bti\bif\bfy\by %\b%job ...
         Causes the shell to notify the user asynchronously when
         the status of the current or specified jobs changes;
         normally notification is presented before a prompt.
         This is automatic if the shell variable _\bn_\bo_\bt_\bi_\bf_\by is set.

    o\bon\bni\bin\bnt\btr\br
    o\bon\bni\bin\bnt\btr\br  -
    o\bon\bni\bin\bnt\btr\br  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 _\bo_\bn_\bi_\bn_\bt_\br have
         no meaning and interrupts continue to be ignored by the
         shell and all invoked commands.

    p\bpo\bop\bpd\bd
    p\bpo\bop\bpd\bd +n
         Pops the directory stack, returning to the new top
         directory.  With an argument `+_\bn' discards the _\bnth
         entry in the stack.  The elements of the directory
         stack are numbered from 0 starting at the top.

    p\bpu\bus\bsh\bhd\bd
    p\bpu\bus\bsh\bhd\bd name
    p\bpu\bus\bsh\bhd\bd +n
         With no arguments, _\bp_\bu_\bs_\bh_\bd exchanges the top two elements
         of the directory stack.  Given a _\bn_\ba_\bm_\be argument, _\bp_\bu_\bs_\bh_\bd



Printed 7/9/88           April 24, 1988                        20






CSH(1)              UNIX Programmer's Manual               CSH(1)



         changes to the new directory (ala _\bc_\bd) and pushes the
         old current working directory (as in _\bc_\bs_\bw) onto the
         directory stack.  With a numeric argument, rotates the
         _\bnth 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.

    r\bre\beh\bha\bas\bsh\bh
         Causes the internal hash table of the contents of the
         directories in the _\bp_\ba_\bt_\bh variable to be recomputed.
         This is needed if new commands are added to directories
         in the _\bp_\ba_\bt_\bh 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 one of the system directories.

    r\bre\bep\bpe\bea\bat\bt count command
         The specified _\bc_\bo_\bm_\bm_\ba_\bn_\bd which is subject to the same res-
         trictions as the _\bc_\bo_\bm_\bm_\ba_\bn_\bd in the one line _\bi_\bf statement
         above, is executed _\bc_\bo_\bu_\bn_\bt times.  I/O redirections occur
         exactly once, even if _\bc_\bo_\bu_\bn_\bt is 0.

    s\bse\bet\bt
    s\bse\bet\bt name
    s\bse\bet\bt name=word
    s\bse\bet\bt name[index]=word
    s\bse\bet\bt name=(wordlist)
         The first form of the command shows the value of all
         shell variables.  Variables which have other than a
         single word as value print as a parenthesized word
         list.  The second form sets _\bn_\ba_\bm_\be to the null string.
         The third form sets _\bn_\ba_\bm_\be to the single _\bw_\bo_\br_\bd. The fourth
         form sets the _\bi_\bn_\bd_\be_\bx'_\bt_\bh component of name to word; this
         component must already exist.  The final form sets _\bn_\ba_\bm_\be
         to the list of words in _\bw_\bo_\br_\bd_\bl_\bi_\bs_\bt. In all cases the
         value is 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
         occurs.

    s\bse\bet\bte\ben\bnv\bv
    s\bse\bet\bte\ben\bnv\bv name value
    s\bse\bet\bte\ben\bnv\bv name
         The first form lists all current environment variables.
         The last form sets the value of environment variable
         _\bn_\ba_\bm_\be to be _\bv_\ba_\bl_\bu_\be, a single string.  The second form
         sets _\bn_\ba_\bm_\be to an empty string.  The most commonly used
         environment variable USER, TERM, and PATH are automati-
         cally imported to and exported from the _\bc_\bs_\bh variables



Printed 7/9/88           April 24, 1988                        21






CSH(1)              UNIX Programmer's Manual               CSH(1)



         _\bu_\bs_\be_\br, _\bt_\be_\br_\bm, and _\bp_\ba_\bt_\bh; there is no need to use _\bs_\be_\bt_\be_\bn_\bv
         for these.

    s\bsh\bhi\bif\bft\bt
    s\bsh\bhi\bif\bft\bt variable
         The members of _\ba_\br_\bg_\bv are shifted to the left, discarding
         _\ba_\br_\bg_\bv[_\b1]. It is an error for _\ba_\br_\bg_\bv not to be set or to
         have less than one word as value.  The second form per-
         forms the same function on the specified variable.

    s\bso\bou\bur\brc\bce\be name
    s\bso\bou\bur\brc\bce\be -\b-h\bh name
         The shell reads commands from _\bn_\ba_\bm_\be. _\bS_\bo_\bu_\br_\bc_\be commands may
         be nested; if they are nested too deeply the shell may
         run out of file descriptors.  An error in a _\bs_\bo_\bu_\br_\bc_\be at
         any level terminates all nested _\bs_\bo_\bu_\br_\bc_\be commands.  Nor-
         mally input during _\bs_\bo_\bu_\br_\bc_\be commands is not placed on the
         history list; the -h option causes the commands to be
         placed in the history list without being executed.

    s\bst\bto\bop\bp
    s\bst\bto\bop\bp %\b%job ...
         Stops the current or specified job which is executing
         in the background.

    s\bsu\bus\bsp\bpe\ben\bnd\bd
         Causes the shell to stop in its tracks, much as if it
         had been sent a stop signal with ^\b^Z\bZ.      This is most
         often used to stop shells started by _\bs_\bu(1).

    s\bsw\bwi\bit\btc\bch\bh (string)
    c\bca\bas\bse\be str1:
        ...
      b\bbr\bre\bea\bak\bks\bsw\bw
    ...
    d\bde\bef\bfa\bau\bul\blt\bt:\b:
        ...
      b\bbr\bre\bea\bak\bks\bsw\bw
    e\ben\bnd\bds\bsw\bw
         Each case label is successively matched, against the
         specified _\bs_\bt_\br_\bi_\bn_\bg which is first command and filename
         expanded.  The file metacharacters `*', `?' and `[...]'
         may be used in the case labels, which are variable
         expanded.  If none of the labels match before a
         `default' label is found, then the execution begins
         after the default label.  Each case label and the
         default label must appear at the beginning of a line.
         The command _\bb_\br_\be_\ba_\bk_\bs_\bw causes execution to continue after
         the _\be_\bn_\bd_\bs_\bw. Otherwise control may fall through case
         labels and default labels as in C.  If no label matches
         and there is no default, execution continues after the
         _\be_\bn_\bd_\bs_\bw.



Printed 7/9/88           April 24, 1988                        22






CSH(1)              UNIX Programmer's Manual               CSH(1)



    t\bti\bim\bme\be
    t\bti\bim\bme\be command
         With no argument, a summary of time used by this shell
         and its children is printed.  If arguments are given
         the specified simple command is timed and a time sum-
         mary as described under the _\bt_\bi_\bm_\be variable is printed.
         If necessary, an extra shell is created to print the
         time statistic when the command completes.

    u\bum\bma\bas\bsk\bk
    u\bum\bma\bas\bsk\bk value
         The file creation mask is displayed (first form) or set
         to the specified value (second form).  The mask is
         given in octal.  Common values for the mask are 002
         giving all access to the group and read and execute
         access to others or 022 giving all access except no
         write access for users in the group or others.

    u\bun\bna\bal\bli\bia\bas\bs pattern
         All aliases whose names match the specified pattern are
         discarded.  Thus all aliases are removed by `unalias
         *'.  It is not an error for nothing to be _\bu_\bn_\ba_\bl_\bi_\ba_\bs_\be_\bd.

    u\bun\bnh\bha\bas\bsh\bh
         Use of the internal hash table to speed location of
         executed programs is disabled.

    u\bun\bnl\bli\bim\bmi\bit\bt
    u\bun\bnl\bli\bim\bmi\bit\bt _\br_\be_\bs_\bo_\bu_\br_\bc_\be
    u\bun\bnl\bli\bim\bmi\bit\bt -\b-h\bh
    u\bun\bnl\bli\bim\bmi\bit\bt -\b-h\bh _\br_\be_\bs_\bo_\bu_\br_\bc_\be
         Removes the limitation on _\br_\be_\bs_\bo_\bu_\br_\bc_\be.  If no _\br_\be_\bs_\bo_\bu_\br_\bc_\be is
         specified, then all _\br_\be_\bs_\bo_\bu_\br_\bc_\be limitations are removed.
         If -\b-h\bh is given, the corresponding hard limits are
         removed.  Only the super-user may do this.

    u\bun\bns\bse\bet\bt pattern
         All variables whose names match the specified pattern
         are removed.  Thus all variables are removed by `unset
         *'; this has noticeably distasteful side-effects.  It
         is not an error for nothing to be _\bu_\bn_\bs_\be_\bt.

    u\bun\bns\bse\bet\bte\ben\bnv\bv pattern
         Removes all variables whose name match the specified
         pattern from the environment.  See also the _\bs_\be_\bt_\be_\bn_\bv com-
         mand above and _\bp_\br_\bi_\bn_\bt_\be_\bn_\bv(1).

    w\bwa\bai\bit\bt
         All background jobs are waited for.  It the shell is
         interactive, then an interrupt can disrupt the wait, at
         which time the shell prints names and job numbers of
         all jobs known to be outstanding.



Printed 7/9/88           April 24, 1988                        23






CSH(1)              UNIX Programmer's Manual               CSH(1)



    w\bwh\bhi\bil\ble\be (expr)
        ...
    e\ben\bnd\bd
         While the specified expression evaluates non-zero, the
         commands between the _\bw_\bh_\bi_\bl_\be and the matching end are
         evaluated.  _\bB_\br_\be_\ba_\bk and _\bc_\bo_\bn_\bt_\bi_\bn_\bu_\be may be used to terminate
         or continue the loop prematurely.  (The _\bw_\bh_\bi_\bl_\be and _\be_\bn_\bd
         must appear alone on their input lines.) Prompting
         occurs here the first time through the loop as for the
         _\bf_\bo_\br_\be_\ba_\bc_\bh statement if the input is a terminal.

    %\b%job
         Brings the specified job into the foreground.

    %\b%job &\b&
         Continues the specified job in the background.

    @\b@
    @\b@ name = expr
    @\b@ name[index] = expr
         The first form prints the values of all the shell vari-
         ables.  The second form sets the specified _\bn_\ba_\bm_\be to the
         value of _\be_\bx_\bp_\br. If the expression contains `<', `>', `&'
         or `|' then at least this part of the expression must
         be placed within `(' `)'.  The third form assigns the
         value of _\be_\bx_\bp_\br to the _\bi_\bn_\bd_\be_\bx'_\bt_\bh argument of _\bn_\ba_\bm_\be. Both
         _\bn_\ba_\bm_\be and its _\bi_\bn_\bd_\be_\bx'_\bt_\bh component must already exist.

         The operators `*=', `+=', etc are available as in C.
         The space separating the name from the assignment
         operator is optional.  Spaces are, however, mandatory
         in separating components of _\be_\bx_\bp_\br which would otherwise
         be single words.

         Special postfix `++' and `--' operators increment and
         decrement _\bn_\ba_\bm_\be respectively, i.e. `@  i++'.

    P\bPr\bre\be-\b-d\bde\bef\bfi\bin\bne\bed\bd a\ban\bnd\bd e\ben\bnv\bvi\bir\bro\bon\bnm\bme\ben\bnt\bt v\bva\bar\bri\bia\bab\bbl\ble\bes\bs

    The following variables have special meaning to the shell.
    Of these, _\ba_\br_\bg_\bv, _\bc_\bw_\bd, _\bh_\bo_\bm_\be, _\bp_\ba_\bt_\bh, _\bp_\br_\bo_\bm_\bp_\bt, _\bs_\bh_\be_\bl_\bl and _\bs_\bt_\ba_\bt_\bu_\bs
    are always set by the shell.  Except for _\bc_\bw_\bd and _\bs_\bt_\ba_\bt_\bu_\bs this
    setting occurs only at initialization; these variables will
    not then be modified unless this is done explicitly by the
    user.

    This shell copies the environment variable USER into the
    variable _\bu_\bs_\be_\br, TERM into _\bt_\be_\br_\bm, and HOME into _\bh_\bo_\bm_\be, and
    copies these back into the environment whenever the normal
    shell variables are reset.  The environment variable PATH is
    likewise handled; it is not necessary to worry about its
    setting other than in the file ._\bc_\bs_\bh_\br_\bc as inferior _\bc_\bs_\bh



Printed 7/9/88           April 24, 1988                        24






CSH(1)              UNIX Programmer's Manual               CSH(1)



    processes will import the definition of _\bp_\ba_\bt_\bh from the
    environment, and re-export it if you then change it.

    a\bar\brg\bgv\bv           Set to the arguments to the shell, it is from
                   this variable that positional parameters are
                   substituted, i.e. `$1' is replaced by
                   `$argv[1]', etc.

    c\bcd\bdp\bpa\bat\bth\bh     Gives a list of alternate directories
                   searched to find subdirectories in _\bc_\bh_\bd_\bi_\br com-
                   mands.

    c\bcw\bwd\bd      The full pathname of the current directory.

    e\bec\bch\bho\bo           Set when the -\b-x\bx command line option is given.
                   Causes each command and its arguments to be
                   echoed just before it is executed.  For non-
                   builtin commands all expansions occur before
                   echoing.  Builtin commands are echoed before
                   command and filename substitution, since
                   these substitutions are then done selec-
                   tively.

    f\bfi\bil\ble\bec\bc        Enable file name completion.

    h\bhi\bis\bst\btc\bch\bha\bar\brs\bs            Can be given a string value to change the
                   characters used in history substitution.  The
                   first character of its value is used as the
                   history substitution character, replacing the
                   default character !.  The second character of
                   its value replaces the character |\b^ in quick
                   substitutions.

    h\bhi\bis\bst\bto\bor\bry\by          Can be given a numeric value to control the
                   size of the history list.  Any command which
                   has been referenced in this many events will
                   not be discarded.  Too large values of _\bh_\bi_\bs_\b-
                   _\bt_\bo_\br_\by may run the shell out of memory.  The
                   last executed command is always saved on the
                   history list.

    h\bho\bom\bme\be           The home directory of the invoker, initial-
                   ized from the environment.  The filename
                   expansion of `~\b~' refers to this variable.

    i\big\bgn\bno\bor\bre\bee\beo\bof\bf            If set the shell ignores end-of-file from
                   input devices which are terminals.  This
                   prevents shells from accidentally being
                   killed by control-D's.

    m\bma\bai\bil\bl           The files where the shell checks for mail.
                   This is done after each command completion



Printed 7/9/88           April 24, 1988                        25






CSH(1)              UNIX Programmer's Manual               CSH(1)



                   which will result in a prompt, if a specified
                   interval has elapsed.  The shell says `You
                   have new mail.' if the file exists with an
                   access time not greater than its modify time.

                   If the first word of the value of _\bm_\ba_\bi_\bl is
                   numeric it specifies a different mail check-
                   ing interval, in seconds, than the default,
                   which is 10 minutes.

                   If multiple mail files are specified, then
                   the shell says `New mail in _\bn_\ba_\bm_\be' when there
                   is mail in the file _\bn_\ba_\bm_\be.

    n\bno\boc\bcl\blo\bob\bbb\bbe\ber\br            As described in the section on _\bI_\bn_\bp_\bu_\bt/_\bo_\bu_\bt_\bp_\bu_\bt,
                   restrictions are placed on output redirection
                   to insure that files are not accidentally
                   destroyed, and that `>>' redirections refer
                   to existing files.

    n\bno\bog\bgl\blo\bob\bb     If set, filename expansion is inhibited.
                   This is most useful in shell scripts which
                   are not dealing with filenames, or after a
                   list of filenames has been obtained and
                   further expansions are not desirable.

    n\bno\bon\bno\bom\bma\bat\btc\bch\bh            If set, it is not an error for a filename
                   expansion to not match any existing files;
                   rather the primitive pattern is returned.  It
                   is still an error for the primitive pattern
                   to be malformed, i.e.  `echo [' still gives
                   an error.

    n\bno\bot\bti\bif\bfy\by     If set, the shell notifies asynchronously of
                   job completions.  The default is to rather
                   present job completions just before printing
                   a prompt.

    p\bpa\bat\bth\bh           Each word of the path variable specifies a
                   directory in which commands are to be sought
                   for execution.  A null word specifies the
                   current directory.  If there is no _\bp_\ba_\bt_\bh vari-
                   able then only full path names will execute.
                   The usual search path is `.', `/bin' and
                   `/usr/bin', but this may vary from system to
                   system.  For the super-user the default
                   search path is `/etc', `/bin' and `/usr/bin'.
                   A shell which is given neither the -\b-c\bc nor the
                   -\b-t\bt option will normally hash the contents of
                   the directories in the _\bp_\ba_\bt_\bh variable after
                   reading ._\bc_\bs_\bh_\br_\bc, and each time the _\bp_\ba_\bt_\bh vari-
                   able is reset.  If new commands are added to



Printed 7/9/88           April 24, 1988                        26






CSH(1)              UNIX Programmer's Manual               CSH(1)



                   these directories while the shell is active,
                   it may be necessary to give the _\br_\be_\bh_\ba_\bs_\bh or the
                   commands may not be found.

    p\bpr\bro\bom\bmp\bpt\bt     The string which is printed before each com-
                   mand is read from an interactive terminal
                   input.  If a `!' appears in the string it
                   will be replaced by the current event number
                   unless a preceding `\' is given.  Default is
                   `% ', or `# ' for the super-user.

    s\bsa\bav\bve\beh\bhi\bis\bst\bt       is given a numeric value to control the
                   number of entries of the history list that
                   are saved in ~/.history when the user logs
                   out.  Any command which has been referenced
                   in this many events will be saved.  During
                   start up the shell sources ~/.history into
                   the history list enabling history to be saved
                   across logins.  Too large values of _\bs_\ba_\bv_\be_\bh_\bi_\bs_\bt
                   will slow down the shell during start up.

    s\bsh\bhe\bel\bll\bl        The file in which the shell resides.  This is
                   used in forking shells to interpret files
                   which have execute bits set, but which are
                   not executable by the system.  (See the
                   description of _\bN_\bo_\bn-_\bb_\bu_\bi_\bl_\bt_\bi_\bn _\bC_\bo_\bm_\bm_\ba_\bn_\bd _\bE_\bx_\be_\bc_\bu_\bt_\bi_\bo_\bn
                   below.) Initialized to the (system-dependent)
                   home of the shell.

    s\bst\bta\bat\btu\bus\bs     The status returned by the last command.  If
                   it terminated abnormally, then 0200 is added
                   to the status.  Builtin commands which fail
                   return exit status `1', all other builtin
                   commands set status `0'.

    t\bti\bim\bme\be           Controls automatic timing of commands.  If
                   set, then any command which takes more than
                   this many cpu seconds will cause a line giv-
                   ing user, system, and real times and a utili-
                   zation percentage which is the ratio of user
                   plus system times to real time to be printed
                   when it terminates.

    v\bve\ber\brb\bbo\bos\bse\be          Set by the -\b-v\bv command line option, causes the
                   words of each command to be printed after
                   history substitution.

    N\bNo\bon\bn-\b-b\bbu\bui\bil\blt\bti\bin\bn c\bco\bom\bmm\bma\ban\bnd\bd e\bex\bxe\bec\bcu\but\bti\bio\bon\bn

    When a command to be executed is found to not be a builtin
    command the shell attempts to execute the command via
    _\be_\bx_\be_\bc_\bv_\be(2).  Each word in the variable _\bp_\ba_\bt_\bh names a directory



Printed 7/9/88           April 24, 1988                        27






CSH(1)              UNIX Programmer's Manual               CSH(1)



    from which the shell will attempt to execute the command.
    If it is given neither a -\b-c\bc nor a -\b-t\bt option, the shell will
    hash the names in these directories into an internal table
    so that it will only try an _\be_\bx_\be_\bc in a directory if there is
    a possibility that the command resides there.  This greatly
    speeds command location when a large number of directories
    are present in the search path.  If this mechanism has been
    turned off (via _\bu_\bn_\bh_\ba_\bs_\bh), or if the shell was given a -\b-c\bc or
    -\b-t\bt argument, and in any case for each directory component of
    _\bp_\ba_\bt_\bh which does not begin with a `/', the shell concatenates
    with the given command name to form a path name of a file
    which it then attempts to execute.

    Parenthesized commands are always executed in a subshell.
    Thus `(cd ; pwd) ; pwd' prints the _\bh_\bo_\bm_\be directory; leaving
    you where you were (printing this after the home directory),
    while `cd ; pwd' leaves you in the _\bh_\bo_\bm_\be directory.
    Parenthesized commands are most often used to prevent _\bc_\bh_\bd_\bi_\br
    from affecting the current shell.

    If the file has execute permissions but is not an executable
    binary to the system, then it is assumed to be a file con-
    taining shell commands and a new shell is spawned to read
    it.

    If there is an _\ba_\bl_\bi_\ba_\bs for _\bs_\bh_\be_\bl_\bl then the words of the alias
    will be prepended to the argument list to form the shell
    command.  The first word of the _\ba_\bl_\bi_\ba_\bs should be the full
    path name of the shell (e.g. `$shell').  Note that this is a
    special, late occurring, case of _\ba_\bl_\bi_\ba_\bs substitution, and
    only allows words to be prepended to the argument list
    without modification.

    A\bAr\brg\bgu\bum\bme\ben\bnt\bt l\bli\bis\bst\bt p\bpr\bro\boc\bce\bes\bss\bsi\bin\bng\bg

    If argument 0 to the shell is `-' then this is a login
    shell.  The flag arguments are interpreted as follows:

    -\b-b\bb   This flag 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.

    -\b-c\bc   Commands are read from the (single) following argument
         which must be present.  Any remaining arguments are
         placed in _\ba_\br_\bg_\bv.

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



Printed 7/9/88           April 24, 1988                        28






CSH(1)              UNIX Programmer's Manual               CSH(1)



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

    -\b-i\bi   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.

    -\b-n\bn   Commands are parsed, but not executed.  This aids in
         syntactic checking of shell scripts.

    -\b-s\bs   Command input is taken from the standard input.

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

    -\b-v\bv   Causes the _\bv_\be_\br_\bb_\bo_\bs_\be variable to be set, with the effect
         that command input is echoed after history substitu-
         tion.

    -\b-x\bx   Causes the _\be_\bc_\bh_\bo variable to be set, so that commands
         are echoed immediately before execution.

    -\b-V\bV   Causes the _\bv_\be_\br_\bb_\bo_\bs_\be variable to be set even before
         `.cshrc' is executed.

    -\b-X\bX   Is to -\b-x\bx as -\b-V\bV is to -\b-v\bv.\b.

    After processing of flag arguments, if arguments remain but
    none of the -\b-c\bc,\b, -\b-i\bi,\b, -\b-s\bs,\b, or -\b-t\bt options was 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 `#', i.e. if the script does not start
    with a comment.  Remaining arguments initialize the variable
    _\ba_\br_\bg_\bv.

    S\bSi\big\bgn\bna\bal\bl h\bha\ban\bnd\bdl\bli\bin\bng\bg

    The shell normally ignores _\bq_\bu_\bi_\bt signals.  Jobs running
    detached (either by `&' or the _\bb_\bg or %\b%.\b..\b..\b. &\b& commands) are
    immune to signals generated from the keyboard, including
    hangups.  Other signals have the values which the shell
    inherited from its parent.  The shells handling of inter-
    rupts and terminate signals in shell scripts can be con-
    trolled by _\bo_\bn_\bi_\bn_\bt_\br. Login shells catch the _\bt_\be_\br_\bm_\bi_\bn_\ba_\bt_\be signal;
    otherwise this signal is passed on to children from the



Printed 7/9/88           April 24, 1988                        29






CSH(1)              UNIX Programmer's Manual               CSH(1)



    state in the shell's parent.  In no case are interrupts
    allowed when a login shell is reading the file `.logout'.

A\bAU\bUT\bTH\bHO\bOR\bR
    William Joy.  Job control and directory stack features first
    implemented by J.E. Kulp of I.I.A.S.A, Laxenburg, Austria,
    with different syntax than that used now.  File name comple-
    tion code written by Ken Greer, HP Labs.

F\bFI\bIL\bLE\bES\bS
    ~/.cshrc         Read at beginning of execution by each shell.
    ~/.login         Read by login shell, after `.cshrc' at login.
    ~/.logout        Read by login shell, at logout.
    /bin/sh          Standard shell, for shell scripts not starting with a `#'.
    /tmp/sh*         Temporary file for `<<'.
    /etc/passwd      Source of home directories for `~name'.

L\bLI\bIM\bMI\bIT\bTA\bAT\bTI\bIO\bON\bNS\bS
    Words can be no longer than 1024 characters.  The system
    limits argument lists to 10240 characters.  The number of
    arguments to a command which involves filename expansion is
    limited to 1/6'th the number of characters allowed in an
    argument list.  Command substitutions may substitute no more
    characters than are allowed in an argument list.  To detect
    looping, the shell restricts the number of _\ba_\bl_\bi_\ba_\bs substitu-
    tions on a single line to 20.

S\bSE\bEE\bE A\bAL\bLS\bSO\bO
    sh(1), access(2), execve(2), fork(2), killpg(2), pipe(2),
    sigvec(2), umask(2), setrlimit(2), wait(2), tty(4),
    a.out(5), environ(7), `An introduction to the C shell'

B\bBU\bUG\bGS\bS
    When a command is restarted from a stop, the shell prints
    the directory it started in if this is different from the
    current directory; this can be misleading (i.e. wrong) as
    the job may have changed directories internally.

    Shell builtin functions are not stoppable/restartable.  Com-
    mand sequences of the form `a ; b ; c' are also not handled
    gracefully when stopping is attempted.  If you suspend `b',
    the shell will then immediately execute `c'.  This is espe-
    cially noticeable if this expansion results from an _\ba_\bl_\bi_\ba_\bs.
    It suffices to place the sequence of commands in ()'s to
    force it to a subshell, i.e. `( a ; b ; c )'.

    Control over tty output after processes are started is prim-
    itive; perhaps this will inspire someone to work on a good
    virtual terminal interface.  In a virtual terminal interface
    much more interesting things could be done with output con-
    trol.




Printed 7/9/88           April 24, 1988                        30






CSH(1)              UNIX Programmer's Manual               CSH(1)



    Alias substitution is most often used to clumsily simulate
    shell procedures; shell procedures should be provided rather
    than aliases.

    Commands within loops, prompted for by `?', are not placed
    in the _\bh_\bi_\bs_\bt_\bo_\br_\by list.  Control structure should be parsed
    rather than being recognized as built-in commands.  This
    would allow control commands to be placed anywhere, to be
    combined with `|', and to be used with `&' and `;' metasyn-
    tax.

    It should be possible to use the `:' modifiers on the output
    of command substitutions.  All and more than one `:' modif-
    ier should be allowed on `$' substitutions.

    The way the f\bfi\bil\ble\bec\bc facility is implemented is ugly and expen-
    sive.






































Printed 7/9/88           April 24, 1988                        31