![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to flowcontrol CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / help / src / cshell|
Return to flowcontrol CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / help / src / cshell |
1.1 ! root 1: .TI CSHELL/FLOWCONTROL ! 2: Control Statements: Branching and Looping ! 3: ! 4: ! 5: In the C shell, control statements are special built-in commands ! 6: that you enter around or near conventional commands, ! 7: often on separate lines. ! 8: They let you tell the shell how to control the execution ! 9: of the commands they affect. ! 10: This means that instead of having the shell execute all your commands ! 11: one after another as it does normally, ! 12: you can have it skip some or repeat some. ! 13: This ability to skip or repeat commands, called branching and looping, ! 14: respectively, is more powerful than it might sound at first. ! 15: ! 16: Branching control statements are truly useful only inside shell scripts, ! 17: where the shell reads and executes commands from a file ! 18: instead of from the terminal. ! 19: Inside the script they serve mainly to let you store several ! 20: different command sequences compactly, ! 21: specifying ahead of time on what basis you want the shell to ! 22: skip or choose certain statements while the script is running. ! 23: The basis for decisions made while the script is running ! 24: is usually furnished by such things as arguments given to the script, ! 25: the time of day, whether a certain file exists, etc. ! 26: You enter decision points using a special notation called expressions. ! 27: ! 28: Looping control statements are useful both inside shell scripts ! 29: and when entered from the terminal. ! 30: Although they are used to execute commands repeatedly, ! 31: you seldom want to repeat the exact same command, but usually ! 32: one that is close to it. ! 33: To accomplish this you use a special notation called variables to indicate ! 34: where in a command the shell is to substitute the piece of text that ! 35: is to change when the command is repeated. ! 36: ! 37: In general you can best exploit control statements by using them ! 38: non-interactively, that is, by putting them in command scripts ! 39: so that they decide in your absence which commands to execute, ! 40: when, and how often. ! 41: On the other hand, you can use some of the looping statements ! 42: interactively to great advantage. ! 43: ! 44: How can a script of commands do different things from one run to ! 45: the next if the text of the commands does not change? ! 46: The answer is: Only if parts of the commands and decisions ! 47: have been entered by you with the special notation for variables ! 48: and expressions. ! 49: You need a basic working knowledge of variables and expressions ! 50: to understand control statements. ! 51: The next example illustrates the only control structure not requiring ! 52: any special knowledge. ! 53: ! 54: A Simple Example ! 55: ! 56: Normally in a shell script or a terminal session, when the shell ! 57: finishes doing one command, it proceeds to do the command ! 58: on the next line, and then the next, and so forth. ! 59: This usually continues until the end of the script file is reached or ! 60: the end of the terminal session (logout). ! 61: Suppose that instead of this normal behavior ! 62: you wanted to execute the same command 10 times. ! 63: In particular, suppose that you wanted 10 lineprinted ! 64: copies of the file "letter". ! 65: The line, ! 66: .IP ! 67: repeat 10 lpr letter ! 68: .LP ! 69: would use the control statement "repeat" to ! 70: cause the command "lpr letter" to be run 10 times. ! 71: Lines such as these are sometimes called control structures ! 72: because they consist of a control part and a command part. ! 73: ! 74: A More Complicated Example ! 75: ! 76: Most control structures involve several lines and require variables. ! 77: Here is an example of a 4-line structure which looks up some ! 78: words in the Unix dictionary and then displays on the terminal ! 79: all occurrences of them in a file called "paper". ! 80: .IP ! 81: 'nf ! 82: foreach x (sharp ternimal prestidigitation aint unix) ! 83: look $x ! 84: grep $x paper ! 85: end ! 86: .fi ! 87: .LP ! 88: The "foreach" line tells the shell that it must first scan the succeeding ! 89: lines until it finds one with the keyword "end". ! 90: The two intervening commands will be executed in the order they appear ! 91: as many times as there are words in parentheses. ! 92: Before each cycle of the loop begins, ! 93: the variable "x" is set to the next word in the list. ! 94: In the first cycle, the shell executes the two commands ! 95: using "$x" to signify the word "sharp", that is, it performs the command ! 96: "look sharp" followed by "grep sharp paper". ! 97: Then the shell proceeds with the next word on the list, this time ! 98: performing the two commands using "$x" to signify the ! 99: mispelled word "ternimal". ! 100: This continues for each word on the list until they have all been used, ! 101: at which point the shell resumes its normal operation by ! 102: proceeding to the next command, if any, after the "end" statement. ! 103: ! 104: A Summary of Control Statements ! 105: ! 106: There is rarely a situation that requires the use of one ! 107: kind of control statement over another, although some kinds ! 108: are more convenient than others in certain circumstances. ! 109: Here is a summary of the C shell's control statements indicating the ! 110: general form of the first line, special associated words that accompany ! 111: the statement on other lines, whether it is practical to ! 112: use interactively, and the usual purpose. ! 113: ! 114: .nf ! 115: .ne 8 ! 116: Name and First Line Associated Keywords Intr? Usual Purpose ! 117: --------------------------------------------------------------------------- ! 118: if (expression) then, else, endif no conditional branching ! 119: repeat N command yes simple repetition ! 120: while (expression) end, break, continue yes ... until a condition ! 121: foreach x (list) end, break, continue yes ... for each item in list ! 122: goto label label: no unconditional branching ! 123: switch (expression) case, endsw, breaksw no multi-way value branch ! 124: ! 125: .fi ! 126: In the examples that follow I will use C shell variables and expressions ! 127: as if you were already somewhat familiar with them. ! 128: Additional explanation sometimes appears in the form of C shell ! 129: comments (annotations) appended to command lines after a # sign. ! 130: Also, I have followed a common convention in programming languages ! 131: in indenting those commands grouped inside control structures. ! 132: ! 133: The \fBif\fP Statement ! 134: ! 135: This has several different forms, the first one being ! 136: .IP ! 137: \fBif (\fPexpression\fB)\fP command ! 138: .LP ! 139: where the ! 140: \fIcommand\fP ! 141: is executed only if the ! 142: \fIexpression\fP ! 143: is true. ! 144: Here is a script fragment that informs the user of the number ! 145: of files in the current directory. ! 146: .IP ! 147: 'nf ! 148: set x = (*) # variable x gets list of files ! 149: echo -n "There are $#x file" # $#x is number of files in $x ! 150: if ($#x > 1) echo -n "s" # if more than 1, make plural ! 151: echo " in this directory." # end sentence; no -n so add newline ! 152: .fi ! 153: .LP ! 154: Unfortunately, the first form requires the ! 155: \fIcommand\fP ! 156: to be a simple command; ! 157: in other words, no pipelines or multiple commands are allowed, ! 158: even if they are aliased. ! 159: You can avoid this restriction by calling a multi-line ! 160: script in place of \fIcommand\fP, but that takes time. ! 161: It would be more efficient to use the second form of the if statement, ! 162: .IP ! 163: 'nf ! 164: \fBif (\fPexpression\fB) then ! 165: \fPcommands\fB ! 166: ... ! 167: else if (\fPexpression\fB) then ! 168: \fPcommands\fB ! 169: ... ! 170: \&... ! 171: else ! 172: \fPcommands\fB ! 173: ... ! 174: endif\fP ! 175: .fi ! 176: .LP ! 177: The hardest part about this form is to remember ! 178: to type the keyword \fBthen\fP; ! 179: even the most experienced users trip over it fairly often. ! 180: Here is an example of a multi-line \fBif\fP statement ! 181: which checks to see if a file called "readme" exists ! 182: and has read permission; if so it displays it, ! 183: if not it takes other steps. ! 184: .IP ! 185: 'nf ! 186: if (-e readme && -r readme) then # if it exists and is readable ! 187: echo "I have a message." # announce that fact ! 188: cat readme # and display the file ! 189: else if (-e readme) then # else if it exists only ... ! 190: echo "I have a message, but cannot read it." ! 191: exit # complain and exit script ! 192: else # else if it doesn't even exist ! 193: /usr/games/fortune # do something irrational ! 194: endif # this ends the multi-line if ! 195: .fi ! 196: .LP ! 197: ! 198: The \fBrepeat\fP Statement ! 199: ! 200: As you may have gathered, the form of this control statement is ! 201: .IP ! 202: \fBrepeat \fIN command\fR ! 203: .LP ! 204: Unfortunately, the \fIcommand\fP part ! 205: suffers the same restrictions here as in the one-line if statement. ! 206: As a result, it is hard to find uses for the repeat statement. ! 207: One example cited occasionally uses it to make 100 copies of one ! 208: file in another file, as in ! 209: .IP ! 210: repeat 100 cat data >> bigdata ! 211: .LP ! 212: A much more efficient way to do this is ! 213: .IP ! 214: cat `jot -b data 100` > bigdata ! 215: .LP ! 216: using command substitution ! 217: (those quote marks should be grave accents). ! 218: Similarly, our earlier example with "lpr" would have ! 219: been better done with ! 220: .IP ! 221: lpr `jot -b letter 10` ! 222: .LP ! 223: ! 224: The \fBwhile\fP Statement ! 225: ! 226: The general form of the while statement is ! 227: .IP ! 228: 'nf ! 229: \fBwhile (\fPexpression\fB) ! 230: commands ! 231: ... ! 232: end\fP ! 233: .fi ! 234: .LP ! 235: There are no clear cut criteria for determining when to use this ! 236: control statement over another, but in general, use it when ! 237: you want to loop through a sequence of commands until a ! 238: certain condition becomes false. ! 239: On each iteration (cycle through the loop), if \fIexpression\fP ! 240: is true the shell executes the commands up until the ! 241: "end" statement, then begins the next iteration. ! 242: When \fIexpression\fP becomes false, execution continues after ! 243: the "end". ! 244: ! 245: You can enter the while statement at your terminal as well ! 246: as in a script. ! 247: At the terminal, the shell cannot begin processing until the ! 248: entire body of commands up to the "end" have been entered, ! 249: so each time you press RETURN, it reminds you that it still ! 250: expects you to type in "end" sometime by prompting with a "?". ! 251: For example, to print out the numbers from 1 to 300 on your ! 252: terminal with an interactive while loop, ! 253: .IP ! 254: 'nf ! 255: % set n = 1 # variable n starts out 1 ! 256: % while ($n < 301) # while it's less than 301 ! 257: ? echo $n # print it out; shell prompt is "?" ! 258: ? @ n = ($n + 1) # @ is like set, but do arithmetic ! 259: ? end # end of loop; loop starts after RETURN ! 260: .fi ! 261: .LP ! 262: A better way to count to 300 would be "jot 300", ! 263: but this example illustrates three points. ! 264: First, most applications in the C shell that require doing ! 265: a command sequence a certain number of times have this general form. ! 266: The condition that the while loop is waiting to become false ! 267: is an arithmetic relation involving a variable that is ! 268: initialized before the loop, changes inside the loop, ! 269: and is tested in the \fIexpression\fP. ! 270: Secondly, any number of commands could have filled up the ! 271: body of the loop, so this provides a way to get around ! 272: the restriction in the repeat statement of repeating ! 273: only a simple command. ! 274: The counting variable, "n" in this case, need not always be ! 275: used except to be incremented. ! 276: Finally, the variable could have been used to count down ! 277: instead of up, to increase by larger increments, ! 278: or to change using any arithmetic operation. ! 279: The \fIexpression\fP could easily be adjusted to test ! 280: for different arithmetic relations. ! 281: ! 282: As another example, suppose several users need to edit a file called ! 283: "project" from time to time, the contents of which are important ! 284: enough that only one user should be allowed to edit it at a time. ! 285: All the users involved could accomplish this by agreeing among ! 286: themselves only to edit "project" using the script below. ! 287: The while loop causes the shell to ! 288: check every minute whether a file called "lock" exists. ! 289: When it no longer exists, the shell creates the file again, ! 290: letting other users know that someone is currently editing "project", ! 291: and calls up the editor. ! 292: The lock file is removed after editing, and the script is done. ! 293: .IP ! 294: 'nf ! 295: while (-e lock) # while file "lock" exists ... ! 296: echo Trying # tells you that you (still) must wait ! 297: sleep 60 # do nothing for 60 seconds ! 298: end # end of loop; when "lock" gone, proceed ! 299: date > lock # recreate "lock", no matter what with ! 300: vi project # call up vi on data being secured ! 301: rm lock # let others know they can edit "project" ! 302: .fi ! 303: .LP ! 304: The \fBforeach\fP Statement ! 305: ! 306: The general form of the foreach statement is ! 307: .IP ! 308: 'nf ! 309: \fBforeach \fPvar\fB (\fPword1 word2 \fB...) ! 310: commands ! 311: ... ! 312: end\fR ! 313: .fi ! 314: .LP ! 315: As for the while statement there are no clear cut ! 316: criteria for determining when to use the foreach ! 317: statement over another, but in general, use it when ! 318: you want to loop through a sequence of commands to be ! 319: applied to a list of items. ! 320: On each iteration, the variable \fIvar\fP is set to ! 321: the next word in the parenthesized list. ! 322: The shell executes the commands up until the ! 323: "end" statement, then begins the next iteration. ! 324: When there are no unused words left in the list, ! 325: execution continues after the "end". ! 326: The variable \fIvar\fP may be any name you choose, ! 327: and you are not required to use it in the body of the loop. ! 328: Also, the foreach statement is probably used interactively ! 329: more often than any other control structure. ! 330: ! 331: For example, during a terminal session you could ! 332: mail the files "data1", "data2", etc. up to "data7" ! 333: to a user named "fred" using ! 334: .IP ! 335: 'nf ! 336: % foreach f (data1 data2 data3 data4 data5 data6 data7) ! 337: ? mail fred < $f ! 338: ? end ! 339: .fi ! 340: .LP ! 341: The list could have been abbreviated with (data[1-7]). ! 342: All the C shell control structures can be nested (used ! 343: inside one another). ! 344: As an example, the following script copies each of the data files ! 345: above into each of the directories "old", "new", and "current". ! 346: .IP ! 347: 'nf ! 348: foreach d (old new current) # outer loop for directories ! 349: mkdir $d # make the target directory ! 350: foreach f (data[1-7]) # inner loop for files ! 351: cp $f $d # copy (is this efficient?) ! 352: end # end of inner loop ! 353: end # end of outer loop ! 354: .fi ! 355: .LP ! 356: This example above is actually rather inefficient ! 357: because the inner loop (3 statements) could have been ! 358: replaced with the single command "cp data[1-7] $d", ! 359: so that the shell would only create one "cp" process ! 360: per directory instead of 7. ! 361: The lesson to learn is that however tempted you may be ! 362: to use the foreach statement, check to see if the command ! 363: involved takes more than one argument. ! 364: ! 365: The \fBgoto\fP and \fBonintr\fP Statements ! 366: ! 367: The goto statement consists of the word \fBgoto\fP ! 368: followed be a \fIlabel\fP and causes the shell to jump to a ! 369: line beginning with the string \fIlabel\fP ! 370: followed by a : and to begin executing statements there. ! 371: Strictly speaking all of the C shell's branching and ! 372: looping constructs could be built up using combinations ! 373: of just goto and simple if statements. ! 374: Computer scientists tend to be fanatical in their opposition ! 375: to the goto statement, so try not use it in their presence. ! 376: Here is an example of a script that runs "sed" twice ! 377: on each of the command line arguments. ! 378: When there are no arguments left, the script removes ! 379: a temporary file it created and exits. ! 380: If an argument file is really a directory, ! 381: an error message is printed and the temporary file is not removed. ! 382: .IP ! 383: 'nf ! 384: foreach f ($argv) # foreach command argument ! 385: if (-d $f) goto error # if a directory, goto error ! 386: sed -f pass1 $f > /tmp/xyz$$ # sed stores in /tmp/xyz$$ ! 387: sed -f pass2 /tmp/xyz$$ > $f # then stores back in $f ! 388: end # end of foreach ! 389: goto done: # skip the error part ! 390: error: # just label, no other effect ! 391: echo Error - $f is a directory. # print message ! 392: goto end: # exit script avoiding "rm" ! 393: done: # just a label ! 394: rm /tmp/xyz$$ # remove temporary file ! 395: end: # last label, nothing after it ! 396: .LP ! 397: Besides being clumsy, this script would not remove its temporary ! 398: file if the user typed an interrupt to abort the execution prematurely; ! 399: the script would just drop in its tracks. ! 400: This is remedied by the onintr statement, which has the form ! 401: \fBonintr \fIlabel\fR, where \fIlabel\fP is a label to jump ! 402: to whenever the script receives a subsequent interrupt. ! 403: The next example illustrates this, and also converts the goto ! 404: statements into more socially acceptable statements. ! 405: .IP ! 406: 'nf ! 407: onintr done # on interrupt, goto done ! 408: foreach f ($argv) # foreach command argument ! 409: if (-d $f) then # if a directory then ... ! 410: echo Error - $f is a directory. ! 411: exit # exit, but leave temp file ! 412: endif # end of if statement ! 413: sed -f pass1 $f > /tmp/xyz$$ # sed stores in /tmp/xyz$$ ! 414: sed -f pass2 /tmp/xyz$$ > $f # then stores back in $f ! 415: end # end of foreach ! 416: done: # label for onintr ! 417: rm /tmp/xyz$$ # remove temporary file ! 418: .fi ! 419: .LP ! 420: The \fBswitch\fP Statement ! 421: ! 422: This is like a multi-line if statement which branches only ! 423: on the value of one expression. ! 424: It is usually most useful for visually separating the ! 425: different branches taken in response to different values ! 426: of the same thing. ! 427: Without much further ado, here is a meaningless script fragment that ! 428: processes its arguments through a while loop using a switch statement. ! 429: Just before the each next interaction of the loop, the shift command ! 430: causes the current value of "$argv[1]" to be discarded and replaced ! 431: with "$argv[2]". ! 432: .IP ! 433: 'nf ! 434: while ($#argv > 0) ! 435: switch ($argv[1]) ! 436: case -m: ! 437: set m ! 438: breaksw ! 439: case -l*: ! 440: set length = $argv[1] ! 441: breaksw ! 442: case -T: ! 443: set sort = (/usr/lib/sort) ! 444: set lpr = (/usr/ucb/lpr -Pevans1) ! 445: breaksw ! 446: case -Y: ! 447: set sort = (/usr/lib/vsort -W) ! 448: set lpr = (/usr/ucb/lpr -Pversatec) ! 449: breaksw ! 450: case -F: ! 451: if ($#argv < 2) then ! 452: echo -F takes following port name. ! 453: exit(1) ! 454: endif ! 455: set argv = (-1 $2.f -2 $2.p -3 $2.o $argv[3-]) ! 456: breaksw ! 457: case -1: ! 458: case -2: ! 459: case -3: ! 460: if ($#argv < 2) then ! 461: echo $1 takes following port name. ! 462: exit(1) ! 463: endif ! 464: breaksw ! 465: case -x: ! 466: set xyzzy ! 467: breaksw ! 468: case -*: ! 469: set flags = ($flags $argv[1]) ! 470: breaksw ! 471: endsw ! 472: shift argv ! 473: end ! 474: .fi ! 475: .LP ! 476: ! 477: ! 478: jak
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.