![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to t3 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 03.shell|
Return to t3 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 03.shell |
1.1 root 1: .\" @(#)t3 6.1 (Berkeley) 5/22/86
2: .\"
3: .SH
4: 3.0\ Keyword\ parameters
5: .LP
6: Shell variables may be given values
7: by assignment
8: or when a shell procedure is invoked.
9: An argument to a shell procedure of the form
10: \fIname=value\fP
11: that precedes the command name
12: causes \fIvalue\fP
13: to be assigned to \fIname\fP
14: before execution of the procedure begins.
15: The value of \fIname\fP in the invoking
16: shell is not affected.
17: For example,
18: .DS
19: user=fred\ command
20: .DE
21: will execute \fIcommand\fP with
22: \fBuser\fP set to \fIfred\fP.
23: The \fB\(mik\fR flag causes arguments of the form
24: \fIname=value\fP to be interpreted in this way
25: anywhere in the argument list.
26: Such \fInames\fP are sometimes
27: called keyword parameters.
28: If any arguments remain they
29: are available as positional
30: parameters \fB$1, $2, \*(ZZ\|.\fP
31: .LP
32: The \fIset\fP command
33: may also be used to set positional parameters
34: from within a procedure.
35: For example,
36: .DS
37: set\ \(mi\ \*(ST
38: .DE
39: will set \fB$1\fP to the first file name
40: in the current directory, \fB$2\fP to the next,
41: and so on.
42: Note that the first argument, \(mi, ensures correct treatment
43: when the first file name begins with a \(mi\|.
44: .LP
45: .SH
46: 3.1\ Parameter\ transmission
47: .LP
48: When a shell procedure is invoked both positional
49: and keyword parameters may be supplied with the call.
50: Keyword parameters are also made available implicitly
51: to a shell procedure
52: by specifying in advance that such parameters
53: are to be exported.
54: For example,
55: .DS
56: export\ user\ box
57: .DE
58: marks the variables \fBuser\fP and \fBbox\fP
59: for export.
60: When a shell procedure is invoked
61: copies are made of all exportable variables
62: for use within the invoked procedure.
63: Modification of such variables
64: within the procedure does not
65: affect the values in the invoking shell.
66: It is generally true of
67: a shell procedure
68: that it
69: may not modify the state
70: of its caller without explicit
71: request on the part of the caller.
72: (Shared file descriptors are an
73: exception to this rule.)
74: .LP
75: Names whose value is intended to remain
76: constant may be declared \fIreadonly\|.\fP
77: The form of this command is the same as that of the \fIexport\fP
78: command,
79: .DS
80: readonly name \*(ZZ
81: .DE
82: Subsequent attempts to set readonly variables
83: are illegal.
84: .SH
85: 3.2\ Parameter\ substitution
86: .LP
87: If a shell parameter is not set
88: then the null string is substituted for it.
89: For example, if the variable \fBd\fP
90: is not set
91: .DS
92: echo $d
93: .DE
94: or
95: .DS
96: echo ${d}
97: .DE
98: will echo nothing.
99: A default string may be given
100: as in
101: .DS
102: echo ${d\(mi\fB.\fR}
103: .DE
104: which will echo
105: the value of the variable \fBd\fP
106: if it is set and `\fB.\fP' otherwise.
107: The default string is evaluated using the usual
108: quoting conventions so that
109: .DS
110: echo ${d\(mi\'\*(ST\'}
111: .DE
112: will echo \fB\*(ST\fP if the variable \fBd\fP
113: is not set.
114: Similarly
115: .DS
116: echo ${d\(mi$1}
117: .DE
118: will echo the value of \fBd\fP if it is set
119: and the value (if any) of \fB$1\fP otherwise.
120: A variable may be assigned a default value
121: using
122: the notation
123: .DS
124: echo ${d=\fB.\fR}
125: .DE
126: which substitutes the same string as
127: .DS
128: echo ${d\(mi\fB.\fR}
129: .DE
130: and if \fBd\fP were not previously set
131: then it will be set to the string `\fB.\fP'\|.
132: (The notation ${\*(ZZ=\*(ZZ}
133: is not available for positional parameters.)
134: .LP
135: If there is no sensible default then
136: the notation
137: .DS
138: echo ${d?message}
139: .DE
140: will echo the value of the variable \fBd\fP if it has
141: one, otherwise \fImessage\fP is printed by the shell and
142: execution of the shell procedure is abandoned.
143: If \fImessage\fP is absent then a standard message
144: is printed.
145: A shell procedure that requires some parameters
146: to be set might start as follows.
147: .DS
148: :\ ${user?}\ ${acct?}\ ${bin?}
149: \*(ZZ
150: .DE
151: Colon (\fB:\fP) is a command
152: that is
153: built in to the shell and does nothing
154: once its arguments have been evaluated.
155: If any of the variables \fBuser, acct\fP
156: or \fBbin\fP are not set then the shell
157: will abandon execution of the procedure.
158: .SH
159: 3.3\ Command\ substitution
160: .LP
161: The standard output from a command can be
162: substituted in a similar way to parameters.
163: The command \fIpwd\fP prints on its standard
164: output the name of the current directory.
165: For example, if the current directory is
166: \fB/usr/fred/bin\fR
167: then the command
168: .DS
169: d=\`pwd\`
170: .DE
171: is equivalent to
172: .DS
173: d=/usr/fred/bin
174: .DE
175: .LP
176: The entire string between grave accents (\`\*(ZZ\`)
177: is taken as the command
178: to be executed
179: and is replaced with the output from
180: the command.
181: The command is written using the usual
182: quoting conventions
183: except that a \fB\`\fR must be escaped using
184: a \fB\\\|.\fR
185: For example,
186: .DS
187: ls \`echo "$1"\`
188: .DE
189: is equivalent to
190: .DS
191: ls $1
192: .DE
193: Command substitution occurs in all contexts
194: where parameter substitution occurs (including \fIhere\fP documents) and the
195: treatment of the resulting text is the same
196: in both cases.
197: This mechanism allows string
198: processing commands to be used within
199: shell procedures.
200: An example of such a command is \fIbasename\fP
201: which removes a specified suffix from a string.
202: For example,
203: .DS
204: basename main\fB.\fPc \fB.\fPc
205: .DE
206: will print the string \fImain\|.\fP
207: Its use is illustrated by the following
208: fragment from a \fIcc\fP command.
209: .DS
210: case $A in
211: \*(Ca\*(ZZ
212: \*(Ca\*(ST\fB.\fPc) B=\`basename $A \fB.\fPc\`
213: \*(Ca\*(ZZ
214: esac
215: .DE
216: that sets \fBB\fP to the part of \fB$A\fP
217: with the suffix \fB.c\fP stripped.
218: .LP
219: Here are some composite examples.
220: .RS
221: .IP \(bu
222: .ft B
223: for i in \`ls \(mit\`; do \*(ZZ
224: .ft R
225: .br
226: The variable \fBi\fP is set
227: to the names of files in time order,
228: most recent first.
229: .IP \(bu
230: .ft B
231: set \`date\`; echo $6 $2 $3, $4
232: .ft R
233: .br
234: will print, e.g.,
235: .ft I
236: 1977 Nov 1, 23:59:59
237: .ft R
238: .RE
239: .SH
240: 3.4\ Evaluation\ and\ quoting
241: .LP
242: The shell is a macro processor that
243: provides parameter substitution, command substitution and file
244: name generation for the arguments to commands.
245: This section discusses the order in which
246: these evaluations occur and the
247: effects of the various quoting mechanisms.
248: .LP
249: Commands are parsed initially according to the grammar
250: given in appendix A.
251: Before a command is executed
252: the following
253: substitutions occur.
254: .RS
255: .IP \(bu
256: parameter substitution, e.g. \fB$user\fP
257: .IP \(bu
258: command substitution, e.g. \fB\`pwd\`\fP
259: .RS
260: .LP
261: Only one evaluation occurs so that if, for example, the value of the variable
262: \fBX\fP
263: is the string \fI$y\fP
264: then
265: .DS
266: echo $X
267: .DE
268: will echo \fI$y\|.\fP
269: .RE
270: .IP \(bu
271: blank interpretation
272: .RS
273: .LP
274: Following the above substitutions
275: the resulting characters
276: are broken into non-blank words (\fIblank interpretation\fP).
277: For this purpose `blanks' are the characters of the string
278: \fB$\s-1IFS\s0\fP.
279: By default, this string consists of blank, tab and newline.
280: The null string
281: is not regarded as a word unless it is quoted.
282: For example,
283: .DS
284: echo \'\'
285: .DE
286: will pass on the null string as the first argument to \fIecho\fP,
287: whereas
288: .DS
289: echo $null
290: .DE
291: will call \fIecho\fR with no arguments
292: if the variable \fBnull\fP is not set
293: or set to the null string.
294: .RE
295: .IP \(bu
296: file name generation
297: .RS
298: .LP
299: Each word
300: is then scanned for the file pattern characters
301: \fB\*(ST, ?\fR and \fB[\*(ZZ]\fR
302: and an alphabetical list of file names
303: is generated to replace the word.
304: Each such file name is a separate argument.
305: .RE
306: .RE
307: .LP
308: The evaluations just described also occur
309: in the list of words associated with a \fBfor\fP
310: loop.
311: Only substitution occurs
312: in the \fIword\fP used
313: for a \fBcase\fP branch.
314: .LP
315: As well as the quoting mechanisms described
316: earlier using \fB\\\fR and \fB\'\*(ZZ\'\fR
317: a third quoting mechanism is provided using double quotes.
318: Within double quotes parameter and command substitution
319: occurs but file name generation and the interpretation
320: of blanks does not.
321: The following characters
322: have a special meaning within double quotes
323: and may be quoted using \fB\\\|.\fP
324: .DS
325: \fB$ \fPparameter substitution
326: \fB\`\fP command substitution
327: \fB"\fP ends the quoted string
328: \fB\e\fP quotes the special characters \fB$ \` " \e\fP
329: .DE
330: For example,
331: .DS
332: echo "$x"
333: .DE
334: will pass the value of the variable \fBx\fP as a
335: single argument to \fIecho.\fP
336: Similarly,
337: .DS
338: echo "$\*(ST"
339: .DE
340: will pass the positional parameters as a single
341: argument and is equivalent to
342: .DS
343: echo "$1 $2 \*(ZZ"
344: .DE
345: The notation \fB$@\fP
346: is the same as \fB$\*(ST\fR
347: except when it is quoted.
348: .DS
349: echo "$@"
350: .DE
351: will pass the positional parameters, unevaluated, to \fIecho\fR
352: and is equivalent to
353: .DS
354: echo "$1" "$2" \*(ZZ
355: .DE
356: .LP
357: The following table gives, for each quoting mechanism,
358: the shell metacharacters that are evaluated.
359: .DS
360: .ce
361: .ft I
362: metacharacter
363: .ft
364: .in 1.5i
365: \e $ * \` " \'
366: \' n n n n n t
367: \` y n n t n n
368: " y y n y t n
369:
370: t terminator
371: y interpreted
372: n not interpreted
373:
374: .in
375: .ft B
376: .ce
377: Figure 2. Quoting mechanisms
378: .ft
379: .DE
380: .LP
381: In cases where more than one evaluation of a string
382: is required the built-in command \fIeval\fP
383: may be used.
384: For example,
385: if the variable \fBX\fP has the value
386: \fI$y\fP, and if \fBy\fP has the value \fIpqr\fP
387: then
388: .DS
389: eval echo $X
390: .DE
391: will echo the string \fIpqr\|.\fP
392: .LP
393: In general the \fIeval\fP command
394: evaluates its arguments (as do all commands)
395: and treats the result as input to the shell.
396: The input is read and the resulting command(s)
397: executed.
398: For example,
399: .DS
400: wg=\\'eval who\*(VTgrep\\'
401: $wg fred
402: .DE
403: is equivalent to
404: .DS
405: who\*(VTgrep fred
406: .DE
407: In this example,
408: \fIeval\fP is required
409: since there is no interpretation
410: of metacharacters, such as \fB\*(VT\|,\fP following
411: substitution.
412: .SH
413: 3.5\ Error\ handling
414: .LP
415: The treatment of errors detected by
416: the shell depends on the type of error
417: and on whether the shell is being
418: used interactively.
419: An interactive shell is one whose
420: input and output are connected
421: to a terminal (as determined by
422: \fIgtty\fP (2)).
423: A shell invoked with the \fB\(mii\fP
424: flag is also interactive.
425: .LP
426: Execution of a command (see also 3.7) may fail
427: for any of the following reasons.
428: .IP \(bu
429: Input output redirection may fail.
430: For example, if a file does not exist
431: or cannot be created.
432: .IP \(bu
433: The command itself does not exist
434: or cannot be executed.
435: .IP \(bu
436: The command terminates abnormally,
437: for example, with a "bus error"
438: or "memory fault".
439: See Figure 2 below for a complete list
440: of UNIX signals.
441: .IP \(bu
442: The command terminates normally
443: but returns a non-zero exit status.
444: .LP
445: In all of these cases the shell
446: will go on to execute the next command.
447: Except for the last case an error
448: message will be printed by the shell.
449: All remaining errors cause the shell
450: to exit from a command procedure.
451: An interactive shell will return
452: to read another command from the terminal.
453: Such errors include the following.
454: .IP \(bu
455: Syntax errors.
456: e.g., if \*(ZZ then \*(ZZ done
457: .IP \(bu
458: A signal such as interrupt.
459: The shell waits for the current
460: command, if any, to finish execution and
461: then either exits or returns to the terminal.
462: .IP \(bu
463: Failure of any of the built-in commands
464: such as \fIcd.\fP
465: .LP
466: The shell flag \fB\(mie\fP
467: causes the shell to terminate
468: if any error is detected.
469: .DS
470: 1 hangup
471: 2 interrupt
472: 3* quit
473: 4* illegal instruction
474: 5* trace trap
475: 6* IOT instruction
476: 7* EMT instruction
477: 8* floating point exception
478: 9 kill (cannot be caught or ignored)
479: 10* bus error
480: 11* segmentation violation
481: 12* bad argument to system call
482: 13 write on a pipe with no one to read it
483: 14 alarm clock
484: 15 software termination (from \fIkill\fP (1))
485:
486: .DE
487: .ft B
488: .ce
489: Figure 3. UNIX signals\(dg
490: .ft
491: .FS
492: \(dg Additional signals have been added in Berkeley Unix. See sigvec(2) or signal(3C)
493: for an up-to-date list.
494: .FE
495: Those signals marked with an asterisk
496: produce a core dump
497: if not caught.
498: However,
499: the shell itself ignores quit which is the only
500: external signal that can cause a dump.
501: The signals in this list of potential interest
502: to shell programs are 1, 2, 3, 14 and 15.
503: .SH
504: 3.6\ Fault\ handling
505: .LP
506: Shell procedures normally terminate
507: when an interrupt is received from the
508: terminal.
509: The \fItrap\fP command is used
510: if some cleaning up is required, such
511: as removing temporary files.
512: For example,
513: .DS
514: trap\ \'rm\ /tmp/ps$$; exit\'\ 2
515: .DE
516: sets a trap for signal 2 (terminal
517: interrupt), and if this signal is received
518: will execute the commands
519: .DS
520: rm /tmp/ps$$; exit
521: .DE
522: \fIexit\fP is
523: another built-in command
524: that terminates execution of a shell procedure.
525: The \fIexit\fP is required; otherwise,
526: after the trap has been taken,
527: the shell will resume executing
528: the procedure
529: at the place where it was interrupted.
530: .LP
531: UNIX signals can be handled in one of three ways.
532: They can be ignored, in which case
533: the signal is never sent to the process.
534: They can be caught, in which case the process
535: must decide what action to take when the
536: signal is received.
537: Lastly, they can be left to cause
538: termination of the process without
539: it having to take any further action.
540: If a signal is being ignored
541: on entry to the shell procedure, for example,
542: by invoking it in the background (see 3.7) then \fItrap\fP
543: commands (and the signal) are ignored.
544: .LP
545: The use of \fItrap\fP is illustrated
546: by this modified version of the \fItouch\fP
547: command (Figure 4).
548: The cleanup action is to remove the file \fBjunk$$\fR\|.
549: .DS
550: flag=
551: trap\ \'rm\ \(mif\ junk$$;\ exit\'\ 1 2 3 15
552: for i
553: do\ case\ $i\ in
554: \*(DC\(mic) flag=N ;;
555: \*(DC\*(ST) if\ test\ \(mif\ $i
556: \*(DC then ln\ $i\ junk$$;\ rm\ junk$$
557: \*(DC elif\ test\ $flag
558: \*(DC then echo\ file\ \\\\\'$i\\\\\'\ does\ not\ exist
559: \*(DC else >$i
560: \*(DC fi
561: \*(DOesac
562: done
563: .DE
564: .sp
565: .ft B
566: .ce
567: Figure 4. The touch command
568: .ft
569: .sp
570: The \fItrap\fP command
571: appears before the creation
572: of the temporary file;
573: otherwise it would be
574: possible for the process
575: to die without removing
576: the file.
577: .LP
578: Since there is no signal 0 in UNIX
579: it is used by the shell to indicate the
580: commands to be executed on exit from the
581: shell procedure.
582: .LP
583: A procedure may, itself, elect to
584: ignore signals by specifying the null
585: string as the argument to trap.
586: The following fragment is taken from the
587: \fInohup\fP command.
588: .DS
589: trap \'\' 1 2 3 15
590: .DE
591: which causes \fIhangup, interrupt, quit \fRand\fI kill\fR
592: to be ignored both by the
593: procedure and by invoked commands.
594: .LP
595: Traps may be reset by saying
596: .DS
597: trap 2 3
598: .DE
599: which resets the traps for signals 2 and 3 to their default values.
600: A list of the current values of traps may be obtained
601: by writing
602: .DS
603: trap
604: .DE
605: .LP
606: The procedure \fIscan\fP (Figure 5) is an example
607: of the use of \fItrap\fP where there is no exit
608: in the trap command.
609: \fIscan\fP takes each directory
610: in the current directory, prompts
611: with its name, and then executes
612: commands typed at the terminal
613: until an end of file or an interrupt is received.
614: Interrupts are ignored while executing
615: the requested commands but cause
616: termination when \fIscan\fP is
617: waiting for input.
618: .DS
619: d=\`pwd\`
620: for\ i\ in\ \*(ST
621: do\ if\ test\ \(mid\ $d/$i
622: \*(DOthen\ cd\ $d/$i
623: \*(DO\*(THwhile\ echo\ "$i:"
624: \*(DO\*(TH\*(WHtrap\ exit\ 2
625: \*(DO\*(TH\*(WHread\ x
626: \*(DO\*(THdo\ trap\ :\ 2;\ eval\ $x;\ done
627: \*(DOfi
628: done
629: .DE
630: .sp
631: .ft B
632: .ce
633: Figure 5. The scan command
634: .ft
635: .sp
636: \fIread x\fR is a built-in command that reads one line from the
637: standard input
638: and places the result in the variable \fBx\|.\fP
639: It returns a non-zero exit status if either
640: an end-of-file is read or an interrupt
641: is received.
642: .SH
643: 3.7\ Command\ execution
644: .LP
645: To run a command (other than a built-in) the shell first creates
646: a new process using the system call \fIfork.\fP
647: The execution environment for the command
648: includes input, output and the states of signals, and
649: is established in the child process
650: before the command is executed.
651: The built-in command \fIexec\fP
652: is used in the rare cases when no fork
653: is required
654: and simply replaces the shell with a new command.
655: For example, a simple version of the \fInohup\fP
656: command looks like
657: .DS
658: trap \\'\\' 1 2 3 15
659: exec $\*(ST
660: .DE
661: The \fItrap\fP turns off the signals specified
662: so that they are ignored by subsequently created commands
663: and \fIexec\fP replaces the shell by the command
664: specified.
665: .LP
666: Most forms of input output redirection have already been
667: described.
668: In the following \fIword\fP is only subject
669: to parameter and command substitution.
670: No file name generation or blank interpretation
671: takes place so that, for example,
672: .DS
673: echo \*(ZZ >\*(ST.c
674: .DE
675: will write its output into a file whose name is \fB\*(ST.c\|.\fP
676: Input output specifications are evaluated left to right
677: as they appear in the command.
678: .IP >\ \fIword\fP 12
679: The standard output (file descriptor 1)
680: is sent to the file \fIword\fP which is
681: created if it does not already exist.
682: .IP \*(AP\ \fIword\fP 12
683: The standard output is sent to file \fIword.\fP
684: If the file exists then output is appended
685: (by seeking to the end);
686: otherwise the file is created.
687: .IP <\ \fIword\fP 12
688: The standard input (file descriptor 0)
689: is taken from the file \fIword.\fP
690: .IP \*(HE\ \fIword\fP 12
691: The standard input is taken from the lines
692: of shell input that follow up to but not
693: including a line consisting only of \fIword.\fP
694: If \fIword\fP is quoted then no interpretation
695: of the document occurs.
696: If \fIword\fP is not quoted
697: then parameter and command substitution
698: occur and \fB\\\fP is used to quote
699: the characters \fB\\\fP \fB$\fP \fB\`\fP and the first character
700: of \fIword.\fP
701: In the latter case \fB\\newline\fP is ignored (c.f. quoted strings).
702: .IP >&\ \fIdigit\fP 12
703: The file descriptor \fIdigit\fP is duplicated using the system
704: call \fIdup\fP (2)
705: and the result is used as the standard output.
706: .IP <&\ \fIdigit\fP 12
707: The standard input is duplicated from file descriptor \fIdigit.\fP
708: .IP <&\(mi 12
709: The standard input is closed.
710: .IP >&\(mi 12
711: The standard output is closed.
712: .LP
713: Any of the above may be preceded by a digit in which
714: case the file descriptor created is that specified by the digit
715: instead of the default 0 or 1.
716: For example,
717: .DS
718: \*(ZZ 2>file
719: .DE
720: runs a command with message output (file descriptor 2)
721: directed to \fIfile.\fP
722: .DS
723: \*(ZZ 2>&1
724: .DE
725: runs a command with its standard output and message output
726: merged.
727: (Strictly speaking file descriptor 2 is created
728: by duplicating file descriptor 1 but the effect is usually to
729: merge the two streams.)
730: .LP
731: The environment for a command run in the background such as
732: .DS
733: list \*(ST.c \*(VT lpr &
734: .DE
735: is modified in two ways.
736: Firstly, the default standard input
737: for such a command is the empty file \fB/dev/null\|.\fR
738: This prevents two processes (the shell and the command),
739: which are running in parallel, from trying to
740: read the same input.
741: Chaos would ensue
742: if this were not the case.
743: For example,
744: .DS
745: ed file &
746: .DE
747: would allow both the editor and the shell
748: to read from the same input at the same time.
749: .LP
750: The other modification to the environment of a background
751: command is to turn off the QUIT and INTERRUPT signals
752: so that they are ignored by the command.
753: This allows these signals to be used
754: at the terminal without causing background
755: commands to terminate.
756: For this reason the UNIX convention
757: for a signal is that if it is set to 1
758: (ignored) then it is never changed
759: even for a short time.
760: Note that the shell command \fItrap\fP
761: has no effect for an ignored signal.
762: .SH
763: 3.8\ Invoking\ the\ shell
764: .LP
765: The following flags are interpreted by the shell
766: when it is invoked.
767: If the first character of argument zero is a minus,
768: then commands are read from the file \fB.profile\|.\fP
769: .IP \fB\(mic\fP\ \fIstring\fP
770: .br
771: If the \fB\(mic\fP flag is present then
772: commands are read from \fIstring\|.\fP
773: .IP \fB\(mis\fP
774: If the \fB\(mis\fP flag is present or if no
775: arguments remain
776: then commands are read from the standard input.
777: Shell output is written to
778: file descriptor 2.
779: .IP \fB\(mii\fP
780: If the \fB\(mii\fP flag is present or
781: if the shell input and output are attached to a terminal (as told by \fIgtty\fP)
782: then this shell is \fIinteractive.\fP
783: In this case TERMINATE is ignored (so that \fBkill 0\fP
784: does not kill an interactive shell) and INTERRUPT is caught and ignored
785: (so that \fBwait\fP is interruptable).
786: In all cases QUIT is ignored by the shell.
787: .SH
788: Acknowledgements
789: .LP
790: The design of the shell is
791: based in part on the original UNIX shell
792: .[
793: unix command language thompson
794: .]
795: and the PWB/UNIX shell,
796: .[
797: pwb shell mashey unix
798: .]
799: some
800: features having been taken from both.
801: Similarities also exist with the
802: command interpreters
803: of the Cambridge Multiple Access System
804: .[
805: cambridge multiple access system hartley
806: .]
807: and of CTSS.
808: .[
809: ctss
810: .]
811: .LP
812: I would like to thank Dennis Ritchie
813: and John Mashey for many
814: discussions during the design of the shell.
815: I am also grateful to the members of the Computing Science Research Center
816: and to Joe Maranzano for their
817: comments on drafts of this document.
818: .SH
819: .[
820: $LIST$
821: .]
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.