C shell

Overview of the language

The C shell operates one line at a time. Each line is tokenized into a set of words separated by spaces or other characters with special meaning, including parentheses, piping and input/output redirection operators, semicolons, and ampersands.

Basic statements

A basic statement is one that simply runs a command. The first word is taken as name of the command to be run and may be either an internal command, e.g., echo, or an external command. The rest of the words are passed as arguments to the command.

At the basic statement level, here are some of the features of the grammar:

Wildcarding

The C shell, like all Unix shells, treats any command-line argument that contains wildcard characters as a pattern and replaces it with the list of all the filenames that match (see globbing).

• * matches any number of characters.
• ? matches any single character.
• [...] matches any of the characters inside the square brackets. Ranges are allowed, using the hyphen.
• [^...] matches any character not in the set.

The C shell also introduced several notational conveniences (sometimes known as extended globbing), since copied by other Unix shells.

• abc{def,ghi} is alternation (aka brace expansion) and expands to abcdef abcghi.
• ~ means the current user's home directory.
• ~user means user's home directory.

Multiple directory-level wildcards, e.g., "*/*.c", are supported.

Since version 6.17.01, recursive wildcarding in zsh (e.g. "**/*.c" or "***/*.html") is also supported with the globstar option.

Giving the shell the responsibility for interpreting wildcards was an important decision on Unix. It meant that wildcards would work with every command, and always in the same way. However, the decision relied on Unix's ability to pass long argument lists efficiently through the exec system call that csh uses to execute commands. By contrast, on Windows, wildcard interpretation is conventionally performed by each application. This is a legacy of MS-DOS, which only allowed a 128-byte command line to be passed to an application, making wildcarding by the DOS command prompt impractical. Although modern Windows can pass command lines of up to roughly 32K Unicode characters, the burden for wildcard interpretation remains with the application.

I/O redirection

By default, when csh runs a command, the command inherits the csh's stdio file handles for stdin, stdout and stderr, which normally all point to the console window where the C shell is running. The i/o redirection operators allow the command to use a file instead for input or output.

• > file means stdout will be written to file, overwriting it if it exists, and creating it if it doesn't. Errors still come to the shell window.
• >& file means both stdout and stderr will be written to file, overwriting it if it exists, and creating it if it doesn't.
• >> file means stdout will be appended at the end of file.
• >>& file means both stdout and stderr will be appended at the end of file.
• < file means stdin will be read from file.
• << string is a here document. Stdin will read the following lines up to the one that matches string.

Redirecting stderr alone isn't possible without the aid of a sub-shell.

<span id="mwAbA"></span><span class="nb" id="mwAbE">set </span><span class="nv" id="mwAbI">filter</span> <span class="o" id="mwAbM">=</span> <span class="s2" id="mwAbQ">"$home"</span><span class="s1" id="mwAbU">'/filter'</span> mkfifo <span class="s2" id="mwAbY">"$filter"</span> cat <span class="s2" id="mwAbc">"$filter"</span> & <span class="o" id="mwAbg">(</span> <span class="o" id="mwAbk">(</span> ls /root/ || <span class="nb" id="mwAbo">echo </span>No access. <span class="o" id="mwAbs">)</span> > <span class="s2" id="mwAbw">"$filter"</span> <span class="o" id="mwAb0">)</span> >& /dev/null

Systems supporting file descriptors as files may use the following workaround.

<span id="mwAcE"></span><span class="o" id="mwAcI">(</span> <span class="o" id="mwAcM">(</span> <span class="o" id="mwAcQ">(</span> <span class="nb" id="mwAcU">echo </span>ok <span class="p" id="mwAcY">;</span> <span class="s1" id="mwAcc">''</span> <span class="o" id="mwAcg">)</span> > /dev/fd/0 <span class="o" id="mwAck">)</span> >& /dev/null < /dev/fd/1 <span class="o" id="mwAco">)</span> | <span class="o" id="mwAcs">(</span> <span class="nb" id="mwAcw">echo</span> <span class="s2" id="mwAc0">"$<"</span> <span class="nb" id="mwAc4">bye</span> <span class="o" id="mwAc8">)</span>

Joining

Commands can be joined on the same line.

• ; means run the first command and then the next.
• && means run the first command and, if it succeeds with a 0 return code, run the next.
• || means run the first command and, if it fails with a non-zero return code, run the next.

Piping

Commands can be connected using a pipe, which causes the output of one command to be fed into the input of the next. Both commands run concurrently.

• | means connect stdout to stdin of the next command. Errors still come to the shell window.
• |& means connect both stdout and stderr to stdin of the next command.

Running concurrently means "in parallel". In a multi-core (multiple processor) system, the piped commands may literally be executing at the same time, otherwise the scheduler in the operating system time-slices between them.

Given a command, e.g., "a | b", the shell creates a pipe, then starts both a and b with stdio for the two commands redirected so that a writes its stdout into the input of the pipe while b reads stdin from the output of the pipe. Pipes are implemented by the operating system with a certain amount of buffering so that a can write for a while before the pipe fills but once the pipe fills any new write will block inside the OS until b reads enough to unblock new writes. If b tries to read more data than is available, it will block until a has written more data or until the pipe closes, e.g., if a exits.

Variable substitution

If a word contains a dollar sign, "$", the following characters are taken as the name of a variable and the reference is replaced by the value of that variable. Various editing operators, typed as suffixes to the reference, allow pathname editing (e.g., ":e" to extract just the extension) and other operations.

Quoting and escaping

Quoting mechanisms allow otherwise special characters, such as whitespace, wildcards, parentheses, and dollar signs, to be taken as literal text.

• \ means take the next character as an ordinary literal character.
• "string" is a weak quote. Enclosed whitespace and wildcards are taken as literals, but variable and command substitutions are still performed.
• 'string' is a strong quote. The entire enclosed string is taken as a literal.

Double quotes inside double quotes should be escaped with "\"". The same applies to the dollar symbol, to prevent variable expansion "\$". For backticks, to prevent command substitution nesting, single quotes are required "'\`'".

Command substitution

Command substitution allows the output of one command to be used as arguments to another.

• `command` means take the output of command, parse it into words and paste them back into the command line.

Background execution

Normally, when the C shell starts a command, it waits for the command to finish before giving the user another prompt signaling that a new command can be typed.

• command & means start command in the background and prompt immediately for a new command.

Subshells

A subshell is a separate child copy of the shell that inherits the current state but can then make changes, e.g., to the current directory, without affecting the parent.

• ( commands ) means run commands in a subshell.

Control structures

The C shell provides control structures for both condition-testing and iteration. The condition-testing control structures are the if and switch statements. The iteration control structures are the while, foreach and repeat statements.

if statement

There are two forms of the if statement. The short form is typed on a single line but can specify only a single command if the expression is true.

<span id="mwAig"></span><span class="k" id="mwAik">if</span> <span class="o" id="mwAio">(</span> expression <span class="o" id="mwAis">)</span> command

The long form uses then, else and endif keywords to allow for blocks of commands to be nested inside the condition.

<span id="mwAi8"></span><span class="k" id="mwAjA">if</span> <span class="o" id="mwAjE">(</span> expression1 <span class="o" id="mwAjI">)</span> <span class="k" id="mwAjM">then</span> <span class="k" id="mwAjQ"> </span>commands <span class="k" id="mwAjU">else if</span> <span class="o" id="mwAjY">(</span> expression2 <span class="o" id="mwAjc">)</span> <span class="k" id="mwAjg">then</span> <span class="k" id="mwAjk"> </span>commands ... <span class="k" id="mwAjo">else</span> <span class="k" id="mwAjs"> </span>commands <span class="k" id="mwAjw">endif</span>

If the else and if keywords appear on the same line, csh chains, rather than nests them; the block is terminated with a single endif.

switch statement

The switch statement compares a string against a list of patterns, which may contain wildcard characters. If nothing matches, the default action, if there is one, is taken.

<span id="mwAkI"></span><span class="k" id="mwAkM">switch</span> <span class="o" id="mwAkQ">(</span> string <span class="o" id="mwAkU">)</span> <span class="k" id="mwAkY">case </span>pattern1: commands <span class="k" id="mwAkc">breaksw</span> <span class="k" id="mwAkg"> case </span>pattern2: commands <span class="k" id="mwAkk">breaksw</span> ... <span class="k" id="mwAko">default</span>: commands <span class="k" id="mwAks">breaksw</span> <span class="k" id="mwAkw">endsw</span>

while statement

The while statement evaluates an expression. If it is true, the shell runs the nested commands and then repeats for as long as the expression remains true.

<span id="mwAlI"></span><span class="k" id="mwAlM">while</span> <span class="o" id="mwAlQ">(</span> expression <span class="o" id="mwAlU">)</span> commands <span class="k" id="mwAlY">end</span>

foreach statement

The foreach statement takes a list of values, usually a list of filenames produced by wildcarding, and then for each, sets the loop variable to that value and runs the nested commands.

<span id="mwAls"></span><span class="k" id="mwAlw">foreach </span>loop-variable <span class="o" id="mwAl0">(</span> list-of-values <span class="o" id="mwAl4">)</span> commands <span class="k" id="mwAl8">end</span>

repeat statement

The repeat statement repeats a single command an integral number of times.

<span id="mwAmQ"></span><span class="nb" id="mwAmU">repeat </span>integer command

Variables

The C shell implements both shell and environment variables. Environment variables, created using the setenv statement, are always simple strings, passed to any child processes, which retrieve these variables via the envp[] argument to main().

Shell variables, created using the set or @ statements, are internal to C shell. They are not passed to child processes. Shell variables can be either simple strings or arrays of strings. Some of the shell variables are predefined and used to control various internal C shell options, e.g., what should happen if a wildcard fails to match anything.

In current versions of csh, strings can be of arbitrary length, well into millions of characters.

Variables can be enlarged as needed. However, if it's desirable to work on a fixed size, the following syntax is preferred.

<span id="mwAno"></span><span class="c" id="mwAns"># Creates a variable large enough to hold 1024 elements.</span> <span class="nb" id="mwAnw">set </span><span class="nv" id="mwAn0">fixed</span> <span class="o" id="mwAn4">=</span> <span class="o" id="mwAn8">{</span>,<span class="o" id="mwAoA">}{</span>,<span class="o" id="mwAoE">}{</span>,<span class="o" id="mwAoI">}{</span>,<span class="o" id="mwAoM">}{</span>,<span class="o" id="mwAoQ">}{</span>,<span class="o" id="mwAoU">}{</span>,<span class="o" id="mwAoY">}{</span>,<span class="o" id="mwAoc">}{</span>,<span class="o" id="mwAog">}{</span>,<span class="o" id="mwAok">}</span>

Expressions

The C shell implements a 32-bit integer expression grammar with operators borrowed from C but with a few additional operators for string comparisons and filesystem tests, e.g., testing for the existence of a file. Operators must be separated by whitespace from their operands. Variables are referenced as $name.

Operator precedence is also borrowed from C, but with different operator associativity rules to resolve the ambiguity of what comes first in a sequence of equal precedence operators. In C, the associativity is left-to-right for most operators; in C shell, it is right-to-left. For example,

<span id="mwApU"></span><span class="c1" id="mwApY">// C groups from the left</span> <span class="kt" id="mwApc">int</span><span class="w" id="mwApg"> </span><span class="n" id="mwApk">i</span><span class="w" id="mwApo"> </span><span class="o" id="mwAps">=</span><span class="w" id="mwApw"> </span><span class="mi" id="mwAp0">10</span><span class="w" id="mwAp4"> </span><span class="o" id="mwAp8">/</span><span class="w" id="mwAqA"> </span><span class="mi" id="mwAqE">5</span><span class="w" id="mwAqI"> </span><span class="o" id="mwAqM">*</span><span class="w" id="mwAqQ"> </span><span class="mi" id="mwAqU">2</span><span class="p" id="mwAqY">;</span> <span class="n" id="mwAqc">printf</span><span class="p" id="mwAqg">(</span><span class="w" id="mwAqk"> </span><span class="s" id="mwAqo">"%d</span><span class="se" id="mwAqs">\n</span><span class="s" id="mwAqw">"</span><span class="p" id="mwAq0">,</span><span class="w" id="mwAq4"> </span><span class="n" id="mwAq8">i</span><span class="w" id="mwArA"> </span><span class="p" id="mwArE">);</span><span class="w" id="mwArI"> </span><span class="c1" id="mwArM">// prints 4</span> <span class="n" id="mwArQ">i</span><span class="w" id="mwArU"> </span><span class="o" id="mwArY">=</span><span class="w" id="mwArc"> </span><span class="mi" id="mwArg">7</span><span class="w" id="mwArk"> </span><span class="o" id="mwAro">-</span><span class="w" id="mwArs"> </span><span class="mi" id="mwArw">4</span><span class="w" id="mwAr0"> </span><span class="o" id="mwAr4">+</span><span class="w" id="mwAr8"> </span><span class="mi" id="mwAsA">2</span><span class="p" id="mwAsE">;</span> <span class="n" id="mwAsI">printf</span><span class="p" id="mwAsM">(</span><span class="w" id="mwAsQ"> </span><span class="s" id="mwAsU">"%d</span><span class="se" id="mwAsY">\n</span><span class="s" id="mwAsc">"</span><span class="p" id="mwAsg">,</span><span class="w" id="mwAsk"> </span><span class="n" id="mwAso">i</span><span class="w" id="mwAss"> </span><span class="p" id="mwAsw">);</span><span class="w" id="mwAs0"> </span><span class="c1" id="mwAs4">// prints 5</span> <span class="n" id="mwAs8">i</span><span class="w" id="mwAtA"> </span><span class="o" id="mwAtE">=</span><span class="w" id="mwAtI"> </span><span class="mi" id="mwAtM">2</span><span class="w" id="mwAtQ"> </span><span class="o" id="mwAtU">>></span><span class="w" id="mwAtY"> </span><span class="mi" id="mwAtc">1</span><span class="w" id="mwAtg"> </span><span class="o" id="mwAtk"><<</span><span class="w" id="mwAto"> </span><span class="mi" id="mwAts">4</span><span class="p" id="mwAtw">;</span> <span class="n" id="mwAt0">printf</span><span class="p" id="mwAt4">(</span><span class="w" id="mwAt8"> </span><span class="s" id="mwAuA">"%d</span><span class="se" id="mwAuE">\n</span><span class="s" id="mwAuI">"</span><span class="p" id="mwAuM">,</span><span class="w" id="mwAuQ"> </span><span class="n" id="mwAuU">i</span><span class="w" id="mwAuY"> </span><span class="p" id="mwAuc">);</span><span class="w" id="mwAug"> </span><span class="c1" id="mwAuk">// prints 16</span>

<span id="mwAuw"></span><span class="c" id="mwAu0"># C shell groups from the right</span> @ <span class="nv" id="mwAu4">i</span> <span class="o" id="mwAu8">=</span> 10 / 5 * 2 <span class="nb" id="mwAvA">echo</span> <span class="nv" id="mwAvE">$i</span> <span class="c" id="mwAvI"># prints 1</span> @ <span class="nv" id="mwAvM">i</span> <span class="o" id="mwAvQ">=</span> 7 - 4 + 2 <span class="nb" id="mwAvU">echo</span> <span class="nv" id="mwAvY">$i</span> <span class="c" id="mwAvc"># prints 1</span> @ <span class="nv" id="mwAvg">i</span> <span class="o" id="mwAvk">=</span> <span class="o" id="mwAvo">(</span> 2 >> 1 << 4 <span class="o" id="mwAvs">)</span> <span class="nb" id="mwAvw">echo</span> <span class="nv" id="mwAv0">$i</span> <span class="c" id="mwAv4"># prints 0</span>

The parentheses in the C shell example are to avoid having the bit-shifting operators confused as I/O redirection operators. In either language, parentheses can always be used to explicitly specify the desired order of evaluation, even if only for clarity.

Return values are limited to 8-bit. For exit expressions, the unary negation operator can be used for 32-bit evaluation.

<span id="mwAwQ"></span><span class="nb" id="mwAwU">exit</span> ! ! 256 <span class="c" id="mwAwY"># Returns 1.</span>

Reception

Although Stephen Bourne himself acknowledged that csh was superior to his shell for interactive use, it has never been as popular for scripting.

In 1983, both csh and Bourne shell were available for Charles River Data Systems' UNOS operating system among other UNIX tools under Bell Laboratories license.

Initially, and through the 1980s, csh could not be guaranteed to be present on all Unix and Unix-like systems, but sh could, which made it a better choice for any scripts that might have to run on other machines. By the mid-1990s, csh was widely available, but the use of csh for scripting faced new criticism by the POSIX committee, which specified that there should only be one preferred shell, the KornShell, for both interactive and scripting purposes. The C shell also faced criticism from others over the C shell's alleged defects in syntax, missing features, and poor implementation.

• Syntax defects: were generally simple but unnecessary inconsistencies in the definition of the language. For example, the set, setenv and alias commands all did basically the same thing, namely, associate a name with a string or set of words. But all three had slight but unnecessary differences. An equal sign was required for a set but not for setenv or alias; parentheses were required around a word list for a set but not for setenv or alias, etc. Similarly, the if, switch and looping constructs use needlessly different keywords (endif, endsw and end) to terminate the nested blocks.
• Missing features: most commonly cited are the lack of ability to manipulate the stdio file handles independently and support for functions. Although lacking support for functions, aliases serve as workaround. For multiple lines of code, aliases must be within single quotes, and each end of line must precede a backslash (the end of the last line must precede a single quote to delimit the end of the alias). Recursion is favorable over aliases in scripts as workaround for functions (an example is given below).
• The implementation: which used an ad hoc parser, has drawn the most serious criticism. By the early 1970s, compiler technology was sufficiently mature that most new language implementations used either a top-down or bottom-up parser capable of recognizing a fully recursive grammar. It is not known why an ad hoc design was chosen instead for the C shell. It may be simply that, as Joy put it in an interview in 2009, "When I started doing this stuff with Unix, I wasn’t a very good programmer." The ad hoc design meant that the C shell language was not fully recursive. There was a limit to how complex a command it could handle.

It worked for most interactively typed commands, but for the more complex commands a user might write in a script, it could easily fail, producing only a cryptic error message or an unwelcome result. For example, the C shell could not support piping between control structures. Attempting to pipe the output of a foreach command into grep simply didn't work. (The work-around, which works for many of the complaints related to the parser, is to break the code up into separate scripts. If the foreach is moved to a separate script, piping works because scripts are run by forking a new copy of csh that does inherit the correct stdio handles. It's also possible to break codes in a single file. An example is given below on how to break codes in a single file.)

Another example is the unwelcome behavior in the following fragments. Both of these appear to mean, "If 'myfile' does not exist, create it by writing 'mytext' into it." But the version on the right always creates an empty file because the C shell's order of evaluation is to look for and evaluate I/O redirection operators on each command line as it reads it, before examining the rest of the line to see whether it contains a control structure.

<span id="mwA04"></span><span class="c1" id="mwA08"># Works as expected</span> <span class="k" id="mwA1A">if</span><span class="w" id="mwA1E"> </span><span class="o" id="mwA1I">(</span><span class="w" id="mwA1M"> </span>!<span class="w" id="mwA1Q"> </span>-e<span class="w" id="mwA1U"> </span>myfile<span class="w" id="mwA1Y"> </span><span class="o" id="mwA1c">)</span><span class="w" id="mwA1g"> </span><span class="k" id="mwA1k">then</span> <span class="w" id="mwA1o"> </span><span class="nb" id="mwA1s">echo</span><span class="w" id="mwA1w"> </span>mytext<span class="w" id="mwA10"> </span>><span class="w" id="mwA14"> </span>myfile endif

<span id="mwA2E"></span><span class="c" id="mwA2I"># Always creates an empty file</span> <span class="k" id="mwA2M">if</span> <span class="o" id="mwA2Q">(</span>! -e myfile<span class="o" id="mwA2U">)</span> <span class="nb" id="mwA2Y">echo </span>mytext > myfile

<span id="mwA2k"></span><span class="c" id="mwA2o"># Workaround (only for tcsh)</span> <span class="k" id="mwA2s">if</span> <span class="o" id="mwA2w">(</span>! -e myfile<span class="o" id="mwA20">)</span> <span class="nb" id="mwA24">eval</span> <span class="s2" id="mwA28">"echo mytext > myfile"</span>

<span id="mwA3I"></span><span class="c" id="mwA3M"># Second workaround (for csh and tcsh)</span> <span class="o" id="mwA3Q">(</span> <span class="nb" id="mwA3U">exit</span> <span class="o" id="mwA3Y">(</span> -e myfile <span class="o" id="mwA3c">)</span> && <span class="o" id="mwA3g">(</span> <span class="o" id="mwA3k">(</span> <span class="nb" id="mwA3o">echo </span>mytext > myfile <span class="o" id="mwA3s">)</span> >& /dev/null || <span class="nb" id="mwA3w">echo </span>Cannot create file. <span class="o" id="mwA30">)</span> || <span class="nb" id="mwA34">echo </span>File exists.

The implementation is also criticized for its notoriously poor error messages, e.g., "0: Event not found.", which yields no useful information about the problem.

However, by practicing, it's possible to overcome those deficiencies (thus instructing the programmer to take better and safer approaches on implementing a script).

The "0: Event not found." error implies there aren't saved commands in the history. The history may not work properly in scripts, but having a pre-set of commands in a variable serves as workaround.

<span id="mwA4Q"></span><span class="c" id="mwA4U">#!/bin/csh -f</span> <span class="nb" id="mwA4Y">set </span><span class="nv" id="mwA4c">cmdlist</span> <span class="o" id="mwA4g">=</span> <span class="o" id="mwA4k">(</span> <span class="s1" id="mwA4o">'date # 1'</span><span class="se" id="mwA4s">\</span> <span class="s1" id="mwA4w">'uname # 2'</span><span class="se" id="mwA40">\</span> <span class="s1" id="mwA44">'tty # 3'</span><span class="se" id="mwA48">\</span> <span class="s1" id="mwA5A">'id # 4'</span> <span class="o" id="mwA5E">)</span> <span class="nb" id="mwA5I">echo</span> -n <span class="s1" id="mwA5M">'Enter a number to execute a command from the history: '</span> <span class="nb" id="mwA5Q">set </span><span class="nv" id="mwA5U">cmdexec</span> <span class="o" id="mwA5Y">=</span> <span class="s2" id="mwA5c">"$<"</span> <span class="o" id="mwA5g">(</span> <span class="nb" id="mwA5k">exit</span> <span class="o" id="mwA5o">(</span> ! <span class="o" id="mwA5s">(</span> <span class="s2" id="mwA5w">"$cmdexec"</span> > 0 && <span class="se" id="mwA50">\</span> <span class="s2" id="mwA54">"$cmdexec"</span> <<span class="o" id="mwA58">=</span> <span class="s2" id="mwA6A">"$#cmdlist"</span> <span class="o" id="mwA6E">)</span> <span class="o" id="mwA6I">)</span> <span class="o" id="mwA6M">)</span> >& /dev/null <span class="k" id="mwA6Q">if</span> <span class="o" id="mwA6U">(</span> <span class="s2" id="mwA6Y">"$status"</span> <span class="o" id="mwA6c">)</span> <span class="k" id="mwA6g">then</span> <span class="k" id="mwA6k"> </span><span class="nb" id="mwA6o">echo</span> <span class="s1" id="mwA6s">'Invalid event number.'</span> <span class="k" id="mwA6w">foreach </span>cmd <span class="o" id="mwA60">(</span> <span class="nv" id="mwA64">$cmdlist</span>:q <span class="o" id="mwA68">)</span> <span class="nb" id="mwA7A">echo</span> <span class="s2" id="mwA7E">"$cmd"</span> <span class="k" id="mwA7I">end</span> <span class="k" id="mwA7M"> </span><span class="nb" id="mwA7Q">exit</span> -1 <span class="k" id="mwA7U">endif</span> <span class="nb" id="mwA7Y">eval</span> <span class="s2" id="mwA7c">"$cmdlist[$cmdexec]"</span>

Prefer breaking codes by recursing the script as workaround for functions.

<span id="mwA7s"></span><span class="c" id="mwA7w">#!/bin/csh -f</span> <span class="k" id="mwA70">if</span> <span class="o" id="mwA74">(</span> ! <span class="s2" id="mwA78">"$?main"</span> <span class="o" id="mwA8A">)</span> <span class="k" id="mwA8E">then</span> <span class="k" id="mwA8I"> if</span> <span class="o" id="mwA8M">(</span> ! <span class="s2" id="mwA8Q">"$?0"</span> <span class="o" id="mwA8U">)</span> <span class="k" id="mwA8Y">then</span> <span class="k" id="mwA8c"> </span><span class="nb" id="mwA8g">echo</span> <span class="s1" id="mwA8k">'You must run this script by explicitly calling its file.'</span> <span class="nb" id="mwA8o">exit</span> -1 <span class="k" id="mwA8s">endif</span> <span class="k" id="mwA8w"> </span><span class="nb" id="mwA80">alias </span>function <span class="s1" id="mwA84">'set argv = ( \!* ) ; source "$main"'</span> <span class="nb" id="mwA88">set </span><span class="nv" id="mwA9A">main</span> <span class="o" id="mwA9E">=</span> <span class="s2" id="mwA9I">"$0"</span> <span class="nb" id="mwA9M">set </span><span class="nv" id="mwA9Q">ret</span> <span class="o" id="mwA9U">=</span> <span class="s2" id="mwA9Y">"`function myfunc`"</span> <span class="nb" id="mwA9c">echo</span> <span class="s2" id="mwA9g">"$ret"</span> <span class="nb" id="mwA9k">exit</span> <span class="k" id="mwA9o">endif</span> <span class="k" id="mwA9s">goto</span> <span class="s2" id="mwA9w">"$1"</span> <span class="p" id="mwA90">;</span> <span class="nb" id="mwA94">shift</span> myfunc: function myfunc2 <span class="nb" id="mwA98">echo</span> <span class="s2" id="mwA-A">"A function."</span> <span class="nb" id="mwA-E">exit</span> myfunc2: <span class="nb" id="mwA-I">echo</span> <span class="s2" id="mwA-M">"Another function."</span> <span class="nb" id="mwA-Q">exit</span>

Influence

The C shell was extremely successful in introducing a large number of innovations including the history mechanism, aliases, tilde notation, interactive filename completion, an expression grammar built into the shell, and more, that have since been copied by other Unix shells. But in contrast to sh, which has spawned a large number of independently developed clones, including ksh and bash, only two csh clones are known. (Since tcsh was based on the csh code originally written by Bill Joy, it is not considered a clone.)

In 1986, Allen Holub wrote On Command: Writing a Unix-Like Shell for MS-DOS, a book describing a program he had written called "SH" but which in fact copied the language design and features of csh, not sh. Companion diskettes containing full source for SH and for a basic set of Unix-like utilities (cat, cp, grep, etc.) were available for $25 and $30, respectively, from the publisher. The control structures, expression grammar, history mechanism and other features in Holub's SH were identical to those of the C shell.

In 1988, Hamilton Laboratories began shipping Hamilton C shell for OS/2. It included both a csh clone and a set of Unix-like utilities. In 1992, Hamilton C shell was released for Windows NT. The Windows version continues to be actively supported but the OS/2 version was discontinued in 2003. An early 1990 quick reference described the intent as "full compliance with the entire C shell language (except job control)" but with improvements to the language design and adaptation to the differences between Unix and a PC. The most important improvement was a top-down parser that allowed control structures to be nested or piped, something the original C shell could not support, given its ad hoc parser. Hamilton also added new language features including built-in and user-defined procedures, block-structured local variables and floating point arithmetic. Adaptation to a PC included support for the filename and other conventions on a PC and the use of threads instead of forks (which were not available under either OS/2 or Windows) to achieve parallelism, e.g., in setting up a pipeline.