![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to csh.3 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 / 04.csh|
Return to csh.3 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 04.csh |
1.1 root 1: .\" Copyright (c) 1980 Regents of the University of California.
2: .\" All rights reserved. The Berkeley software License Agreement
3: .\" specifies the terms and conditions for redistribution.
4: .\"
5: .\" @(#)csh.3 6.1 (Berkeley) 5/23/86
6: .\"
7: .nr H1 2
8: .NH
9: Shell control structures and command scripts
10: .NH 2
11: Introduction
12: .PP
13: It is possible to place commands in files and to cause shells to be
14: invoked to read and execute commands from these files,
15: which are called
16: .I "shell scripts."
17: We here detail those features of the shell useful to the writers of such
18: scripts.
19: .NH 2
20: Make
21: .PP
22: It is important to first note what shell scripts are
23: .I not
24: useful for.
25: There is a program called
26: .I make
27: which is very useful for maintaining a group of related files
28: or performing sets of operations on related files.
29: For instance a large program consisting of one or more files
30: can have its dependencies described in a
31: .I makefile
32: which contains definitions of the commands used to create these
33: different files when changes occur.
34: Definitions of the means for printing listings, cleaning up the directory
35: in which the files reside, and installing the resultant programs
36: are easily, and most appropriately placed in this
37: .I makefile.
38: This format is superior and preferable to maintaining a group of shell
39: procedures to maintain these files.
40: .PP
41: Similarly when working on a document a
42: .I makefile
43: may be created which defines how different versions of the document
44: are to be created and which options of
45: .I nroff
46: or
47: .I troff
48: are appropriate.
49: .NH 2
50: Invocation and the argv variable
51: .PP
52: A
53: .I csh
54: command script may be interpreted by saying
55: .DS
56: % csh script ...
57: .DE
58: where
59: .I script
60: is the name of the file containing a group of
61: .I csh
62: commands and
63: `\&...' is replaced by a sequence of arguments.
64: The shell places these arguments in the variable
65: .I argv
66: and then begins to read commands from the script.
67: These parameters are then available through the same mechanisms
68: which are used to reference any other shell variables.
69: .PP
70: If you make the file
71: `script'
72: executable by doing
73: .DS
74: chmod 755 script
75: .DE
76: and place a shell comment at the beginning of the shell script
77: (i.e. begin the file with a `#' character)
78: then a `/bin/csh' will automatically be invoked to execute `script' when
79: you type
80: .DS
81: script
82: .DE
83: If the file does not begin with a `#' then the standard shell
84: `/bin/sh' will be used to execute it.
85: This allows you to convert your older shell scripts to use
86: .I csh
87: at your convenience.
88: .NH 2
89: Variable substitution
90: .PP
91: After each input line is broken into words and history substitutions
92: are done on it, the input line is parsed into distinct commands.
93: Before each command is executed a mechanism know as
94: .I "variable substitution"
95: is done on these words.
96: Keyed by the character `$' this substitution replaces the names
97: of variables by their values.
98: Thus
99: .DS
100: echo $argv
101: .DE
102: when placed in a command script would cause the current value of the
103: variable
104: .I argv
105: to be echoed to the output of the shell script.
106: It is an error for
107: .I argv
108: to be unset at this point.
109: .PP
110: A number of notations are provided for accessing components and attributes
111: of variables.
112: The notation
113: .DS
114: $?name
115: .DE
116: expands to `1' if name is
117: .I set
118: or to `0'
119: if name is not
120: .I set.
121: It is the fundamental mechanism used for checking whether particular
122: variables have been assigned values.
123: All other forms of reference to undefined variables cause errors.
124: .PP
125: The notation
126: .DS
127: $#name
128: .DE
129: expands to the number of elements in the variable
130: .I name.
131: Thus
132: .DS
133: % set argv=(a b c)
134: % echo $?argv
135: 1
136: % echo $#argv
137: 3
138: % unset argv
139: % echo $?argv
140: 0
141: % echo $argv
142: Undefined variable: argv.
143: %
144: .DE
145: .PP
146: It is also possible to access the components of a variable
147: which has several values.
148: Thus
149: .DS
150: $argv[1]
151: .DE
152: gives the first component of
153: .I argv
154: or in the example above `a'.
155: Similarly
156: .DS
157: $argv[$#argv]
158: .DE
159: would give `c',
160: and
161: .DS
162: $argv[1\-2]
163: .DE
164: would give `a b'. Other notations useful in shell scripts are
165: .DS
166: $\fIn\fR
167: .DE
168: where
169: .I n
170: is an integer as a shorthand for
171: .DS
172: $argv[\fIn\fR\|]
173: .DE
174: the
175: .I n\|th
176: parameter and
177: .DS
178: $*
179: .DE
180: which is a shorthand for
181: .DS
182: $argv
183: .DE
184: The form
185: .DS
186: $$
187: .DE
188: expands to the process number of the current shell.
189: Since this process number is unique in the system it can
190: be used in generation of unique temporary file names.
191: The form
192: .DS
193: $<
194: .DE
195: is quite special and is replaced by the next line of input read from
196: the shell's standard input (not the script it is reading). This is
197: useful for writing shell scripts that are interactive, reading
198: commands from the terminal, or even writing a shell script that
199: acts as a filter, reading lines from its input file. Thus the sequence
200: .DS
201: echo 'yes or no?\ec'
202: set a=($<)
203: .DE
204: would write out the prompt `yes or no?' without a newline and then
205: read the answer into the variable `a'. In this case `$#a' would be
206: `0' if either a blank line or end-of-file (^D) was typed.
207: .PP
208: One minor difference between `$\fIn\fR\|' and `$argv[\fIn\fR\|]'
209: should be noted here.
210: The form
211: `$argv[\fIn\fR\|]'
212: will yield an error if
213: .I n
214: is not in the range
215: `1\-$#argv'
216: while `$n'
217: will never yield an out of range subscript error.
218: This is for compatibility with the way older shells handled parameters.
219: .PP
220: Another important point is that it is never an error to give a subrange
221: of the form `n\-'; if there are less than
222: .I n
223: components of the given variable then no words are substituted.
224: A range of the form `m\-n' likewise returns an empty vector without giving
225: an error when \fIm\fR exceeds the number of elements of the given variable,
226: provided the subscript \fIn\fR is in range.
227: .NH 2
228: Expressions
229: .PP
230: In order for interesting shell scripts to be constructed it
231: must be possible to evaluate expressions in the shell based on the
232: values of variables.
233: In fact, all the arithmetic operations of the language C are available
234: in the shell
235: with the same precedence that they have in C.
236: In particular, the operations `==' and `!=' compare strings
237: and the operators `&&' and `|\|\||' implement the boolean and/or operations.
238: The special operators `=~' and `!~' are similar to `==' and `!=' except
239: that the string on the right side can have pattern matching characters
240: (like *, ? or []) and the test is whether the string on the left matches
241: the pattern on the right.
242: .PP
243: The shell also allows file enquiries of the form
244: .DS
245: \-? filename
246: .DE
247: where `?' is replace by a number of single characters.
248: For instance the expression primitive
249: .DS
250: \-e filename
251: .DE
252: tell whether the file
253: `filename'
254: exists.
255: Other primitives test for read, write and execute access to the file,
256: whether it is a directory, or has non-zero length.
257: .PP
258: It is possible to test whether a command terminates normally,
259: by a primitive of the
260: form `{ command }' which returns true, i.e. `1' if the command
261: succeeds exiting normally with exit status 0, or `0' if the command
262: terminates abnormally or with exit status non-zero.
263: If more detailed information about the execution status of a command
264: is required, it can be executed and the variable `$status' examined
265: in the next command.
266: Since `$status' is set by every command, it is very transient.
267: It can be saved if it is inconvenient to use it only in the single
268: immediately following command.
269: .PP
270: For a full list of expression components available see the manual
271: section for the shell.
272: .NH 2
273: Sample shell script
274: .PP
275: A sample shell script which makes use of the expression mechanism
276: of the shell and some of its control structure follows:
277: .DS
278: % cat copyc
279: #
280: # Copyc copies those C programs in the specified list
281: # to the directory ~/backup if they differ from the files
282: # already in ~/backup
283: #
284: set noglob
285: foreach i ($argv)
286:
287: if ($i !~ *.c) continue # not a .c file so do nothing
288:
289: if (! \-r ~/backup/$i:t) then
290: echo $i:t not in backup... not cp\e\'ed
291: continue
292: endif
293:
294: cmp \-s $i ~/backup/$i:t # to set $status
295:
296: if ($status != 0) then
297: echo new backup of $i
298: cp $i ~/backup/$i:t
299: endif
300: end
301: .DE
302: .PP
303: This script makes use of the
304: .I foreach
305: command, which causes the shell to execute the commands between the
306: .I foreach
307: and the matching
308: .I end
309: for each of the values given between `(' and `)' with the named
310: variable, in this case `i' set to successive values in the list.
311: Within this loop we may use the command
312: .I break
313: to stop executing the loop
314: and
315: .I continue
316: to prematurely terminate one iteration
317: and begin the next.
318: After the
319: .I foreach
320: loop the iteration variable
321: (\fIi\fR in this case)
322: has the value at the last iteration.
323: .PP
324: We set the variable
325: .I noglob
326: here to prevent filename expansion of the members of
327: .I argv.
328: This is a good idea, in general, if the arguments to a shell script
329: are filenames which have already been expanded or if the arguments
330: may contain filename expansion metacharacters.
331: It is also possible to quote each use of a `$' variable expansion,
332: but this is harder and less reliable.
333: .PP
334: The other control construct used here is a statement of the form
335: .DS
336: \fBif\fR ( expression ) \fBthen\fR
337: command
338: ...
339: \fBendif\fR
340: .DE
341: The placement of the keywords here is
342: .B not
343: flexible due to the current implementation of the shell.\(dg
344: .FS
345: \(dgThe following two formats are not currently acceptable to the shell:
346: .sp
347: .in +5
348: .nf
349: \fBif\fR ( expression ) # \fBWon't work!\fR
350: \fBthen\fR
351: command
352: ...
353: \fBendif\fR
354: .fi
355: .in -5
356: .sp
357: and
358: .sp
359: .in +5
360: .nf
361: \fBif\fR ( expression ) \fBthen\fR command \fBendif\fR # \fBWon't work\fR
362: .in -5
363: .fi
364: .FE
365: .PP
366: The shell does have another form of the if statement of the form
367: .DS
368: \fBif\fR ( expression ) \fBcommand\fR
369: .DE
370: which can be written
371: .DS
372: \fBif\fR ( expression ) \e
373: command
374: .DE
375: Here we have escaped the newline for the sake of appearance.
376: The command must not involve `\||\|', `&' or `;'
377: and must not be another control command.
378: The second form requires the final `\e' to
379: .B immediately
380: precede the end-of-line.
381: .PP
382: The more general
383: .I if
384: statements above also admit a sequence of
385: .I else\-if
386: pairs followed by a single
387: .I else
388: and an
389: .I endif,
390: e.g.:
391: .DS
392: \fBif\fR ( expression ) \fBthen\fR
393: commands
394: \fBelse\fR \fBif\fR (expression ) \fBthen\fR
395: commands
396: \&...
397:
398: \fBelse\fR
399: commands
400: \fBendif\fR
401: .DE
402: .PP
403: Another important mechanism used in shell scripts is the `:' modifier.
404: We can use the modifier `:r' here to extract a root of a filename or
405: `:e' to extract the
406: .I extension.
407: Thus if the variable
408: .I i
409: has the value
410: `/mnt/foo.bar'
411: then
412: .sp
413: .in +5
414: .nf
415: % echo $i $i:r $i:e
416: /mnt/foo.bar /mnt/foo bar
417: %
418: .sp
419: .in -5
420: .fi
421: shows how the `:r' modifier strips off the trailing `.bar' and the
422: the `:e' modifier leaves only the `bar'.
423: Other modifiers will take off the last component of a pathname leaving
424: the head `:h' or all but the last component of a pathname leaving the
425: tail `:t'.
426: These modifiers are fully described in the
427: .I csh
428: manual pages in the User's Reference Manual.
429: It is also possible to use the
430: .I "command substitution"
431: mechanism described in the next major section to perform modifications
432: on strings to then reenter the shell's environment.
433: Since each usage of this mechanism involves the creation of a new process,
434: it is much more expensive to use than the `:' modification mechanism.\(dd
435: .FS
436: \(dd It is also important to note that
437: the current implementation of the shell limits the number of `:' modifiers
438: on a `$' substitution to 1.
439: Thus
440: .sp
441: .nf
442: .in +5
443: % echo $i $i:h:t
444: /a/b/c /a/b:t
445: %
446: .in -5
447: .fi
448: .sp
449: does not do what one would expect.
450: .FE
451: Finally, we note that the character `#' lexically introduces a shell
452: comment in shell scripts (but not from the terminal).
453: All subsequent characters on the input line after a `#' are discarded
454: by the shell.
455: This character can be quoted using `\'' or `\e' to place it in
456: an argument word.
457: .NH 2
458: Other control structures
459: .PP
460: The shell also has control structures
461: .I while
462: and
463: .I switch
464: similar to those of C.
465: These take the forms
466: .DS
467: \fBwhile\fR ( expression )
468: commands
469: \fBend\fR
470: .DE
471: and
472: .DS
473: \fBswitch\fR ( word )
474:
475: \fBcase\fR str1:
476: commands
477: \fBbreaksw\fR
478:
479: \& ...
480:
481: \fBcase\fR strn:
482: commands
483: \fBbreaksw\fR
484:
485: \fBdefault:\fR
486: commands
487: \fBbreaksw\fR
488:
489: \fBendsw\fR
490: .DE
491: For details see the manual section for
492: .I csh.
493: C programmers should note that we use
494: .I breaksw
495: to exit from a
496: .I switch
497: while
498: .I break
499: exits a
500: .I while
501: or
502: .I foreach
503: loop.
504: A common mistake to make in
505: .I csh
506: scripts is to use
507: .I break
508: rather than
509: .I breaksw
510: in switches.
511: .PP
512: Finally,
513: .I csh
514: allows a
515: .I goto
516: statement, with labels looking like they do in C, i.e.:
517: .DS
518: loop:
519: commands
520: \fBgoto\fR loop
521: .DE
522: .NH 2
523: Supplying input to commands
524: .PP
525: Commands run from shell scripts receive by default the standard
526: input of the shell which is running the script.
527: This is different from previous shells running
528: under \s-2UNIX\s0. It allows shell scripts to fully participate
529: in pipelines, but mandates extra notation for commands which are to take
530: inline data.
531: .PP
532: Thus we need a metanotation for supplying inline data to commands in
533: shell scripts.
534: As an example, consider this script which runs the editor to
535: delete leading blanks from the lines in each argument file:
536: .DS
537: % cat deblank
538: # deblank \-\- remove leading blanks
539: foreach i ($argv)
540: ed \- $i << \'EOF\'
541: 1,$s/^[ ]*//
542: w
543: q
544: \&\'EOF\'
545: end
546: %
547: .DE
548: The notation `<< \'EOF\''
549: means that the standard input for the
550: .I ed
551: command is to come from the text in the shell script file
552: up to the next line consisting of exactly `\'EOF\''.
553: The fact that the `EOF' is enclosed in `\'' characters, i.e. quoted,
554: causes the shell to not perform variable substitution on the
555: intervening lines.
556: In general, if any part of the word following the `<<' which the
557: shell uses to terminate the text to be given to the command is quoted
558: then these substitutions will not be performed.
559: In this case since we used the form `1,$' in our editor script
560: we needed to insure that this `$' was not variable substituted.
561: We could also have insured this by preceding the `$' here with a `\e',
562: i.e.:
563: .DS
564: 1,\e$s/^[ ]*//
565: .DE
566: but quoting the `EOF' terminator is a more reliable way of achieving the
567: same thing.
568: .NH 2
569: Catching interrupts
570: .PP
571: If our shell script creates temporary files, we may wish to catch
572: interruptions of the shell script so that we can clean up
573: these files.
574: We can then do
575: .DS
576: onintr label
577: .DE
578: where
579: .I label
580: is a label in our program.
581: If an interrupt is received the shell will do a
582: `goto label'
583: and we can remove the temporary files and then do an
584: .I exit
585: command (which is built in to the shell)
586: to exit from the shell script.
587: If we wish to exit with a non-zero status we can do
588: .DS
589: exit(1)
590: .DE
591: e.g. to exit with status `1'.
592: .NH 2
593: What else?
594: .PP
595: There are other features of the shell useful to writers of shell
596: procedures.
597: The
598: .I verbose
599: and
600: .I echo
601: options and the related
602: .I \-v
603: and
604: .I \-x
605: command line options can be used to help trace the actions of the shell.
606: The
607: .I \-n
608: option causes the shell only to read commands and not to execute
609: them and may sometimes be of use.
610: .PP
611: One other thing to note is that
612: .I csh
613: will not execute shell scripts which do not begin with the
614: character `#', that is shell scripts that do not begin with a comment.
615: Similarly, the `/bin/sh' on your system may well defer to `csh'
616: to interpret shell scripts which begin with `#'.
617: This allows shell scripts for both shells to live in harmony.
618: .PP
619: There is also another quotation mechanism using `"' which allows
620: only some of the expansion mechanisms we have so far discussed to occur
621: on the quoted string and serves to make this string into a single word
622: as `\'' does.
623: .bp
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.