![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to u2 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 / 01.begin|
Return to u2 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 01.begin |
1.1 root 1: .\" @(#)u2 6.1 (Berkeley) 5/22/86
2: .\"
3: .SH
4: II. DAY-TO-DAY USE
5: .SH
6: Creating Files \(em The Editor
7: .PP
8: If you have to type a paper or a letter or a program,
9: how do you get the information stored in the machine?
10: Most of these tasks are done with
11: the
12: .UC UNIX
13: ``text editor''
14: .UL ed .
15: Since
16: .UL ed
17: is thoroughly documented in
18: .UL ed (1)
19: and explained in
20: .ul
21: A Tutorial Introduction to the UNIX Text Editor,
22: we won't spend any time here describing how to use it.
23: All we want it for right now is to make some
24: .ul
25: files.
26: (A file is just a collection of information stored in the machine,
27: a simplistic but adequate definition.)
28: .PP
29: To create a file
30: called
31: .UL junk
32: with some text in it, do the following:
33: .P1
34: .ta .65i
35: ed junk \fR(invokes the text editor)\f3
36: a \fR(command to ``ed'', to add text)\f3
37: .ft I
38: now type in
39: whatever text you want ...
40: .ft 3
41: \&. \fR(signals the end of adding text)\f3
42: .P2
43: The ``\f3.\fR'' that signals the end of adding text must be
44: at the beginning of a line by itself.
45: Don't forget it,
46: for until it is typed,
47: no other
48: .UL ed
49: commands will be recognized \(em
50: everything you type will be treated as text to be added.
51: .PP
52: At this point you can do various editing operations
53: on the text you typed in, such as correcting spelling mistakes,
54: rearranging paragraphs and the like.
55: Finally, you must write the information you have typed
56: into a file with the editor command
57: .UL w :
58: .P1
59: w
60: .P2
61: .UL ed
62: will respond with the number of characters it wrote
63: into the file
64: .UL junk .
65: .PP
66: Until the
67: .UL w
68: command,
69: nothing is stored permanently,
70: so if you hang up and go home
71: the information is lost.\(dg
72: .FS
73: \(dg This is not strictly true \(em
74: if you hang up while editing, the data you were
75: working on is saved in a file called
76: .UL ed.hup ,
77: which you can continue with at your next session.
78: .FE
79: But after
80: .UL w
81: the information is there permanently;
82: you can re-access it any time by typing
83: .P1
84: ed junk
85: .P2
86: Type a
87: .UL q
88: command
89: to quit the editor.
90: (If you try to quit without writing,
91: .UL ed
92: will print a
93: .UL ?
94: to remind you.
95: A second
96: .UL q
97: gets you out regardless.)
98: .PP
99: Now create a second file called
100: .UL temp
101: in the same manner.
102: You should now have two files,
103: .UL junk
104: and
105: .UL temp .
106: .SH
107: What files are out there?
108: .PP
109: The
110: .UL ls
111: (for ``list'') command lists the names
112: (not contents)
113: of any of the files that
114: .UC UNIX
115: knows about.
116: If you type
117: .P1
118: ls
119: .P2
120: the response will be
121: .P1
122: junk
123: temp
124: .P2
125: which are indeed the two files just created.
126: The names are sorted into alphabetical order automatically,
127: but other variations are possible.
128: For example,
129: the command
130: .P1
131: ls -t
132: .P2
133: causes the files to be listed in the order in which they were last changed,
134: most recent first.
135: The
136: .UL \-l
137: option gives a ``long'' listing:
138: .P1
139: ls -l
140: .P2
141: will produce something like
142: .P1
143: -rw-rw-rw- 1 bwk 41 Jul 22 2:56 junk
144: -rw-rw-rw- 1 bwk 78 Jul 22 2:57 temp
145: .P2
146: The date and time are of the last change to the file.
147: The 41 and 78 are the number of characters
148: (which should agree with the numbers you got from
149: .UL ed ).
150: .UL bwk
151: is the owner of the file, that is, the person
152: who created it.
153: The
154: .UL \-rw\-rw\-rw\-
155: tells who has permission to read and write the file,
156: in this case everyone.
157: .PP
158: Options can be combined:
159: .UL ls\ \-lt
160: gives the same thing as
161: .UL ls\ \-l ,
162: but sorted into time order.
163: You can also name the files you're interested in,
164: and
165: .UL ls
166: will list the information about them only.
167: More details can be found in
168: .UL ls (1).
169: .PP
170: The use of optional arguments that begin with a minus sign,
171: like
172: .UL \-t
173: and
174: .UL \-lt ,
175: is a common convention for
176: .UC UNIX
177: programs.
178: In general, if a program accepts such optional arguments,
179: they precede any filename arguments.
180: It is also vital that you separate the various arguments with spaces:
181: .UL ls\-l
182: is not the same as
183: .UL ls\ \ \-l .
184: .SH
185: Printing Files
186: .PP
187: Now that you've got a file of text,
188: how do you print it so people can look at it?
189: There are a host of programs that do that,
190: probably more than are needed.
191: .PP
192: One simple thing is to use the editor,
193: since printing is often done just before making changes anyway.
194: You can say
195: .P1
196: ed junk
197: 1,$p
198: .P2
199: .UL ed
200: will reply with the count of the characters in
201: .UL junk
202: and then print all the lines in the file.
203: After you learn how to use the editor,
204: you can be selective about the parts you print.
205: .PP
206: There are times when it's not feasible to use the editor for printing.
207: For example, there is a limit on how big a file
208: .UL ed
209: can handle
210: (several thousand lines).
211: Secondly,
212: it
213: will only print one file at a time,
214: and sometimes you want to print several, one after another.
215: So here are a couple of alternatives.
216: .PP
217: First is
218: .UL cat ,
219: the simplest of all the printing programs.
220: .UL cat
221: simply prints on the terminal the contents of all the files
222: named in a list.
223: Thus
224: .P1
225: cat junk
226: .P2
227: prints one file, and
228: .P1
229: cat junk temp
230: .P2
231: prints two.
232: The files are simply concatenated (hence the name
233: .UL cat '') ``
234: onto the terminal.
235: .PP
236: .UL pr
237: produces formatted printouts of files.
238: As with
239: .UL cat ,
240: .UL pr
241: prints all the files named in a list.
242: The difference is that it produces
243: headings with date, time, page number and file name
244: at the top of each page,
245: and
246: extra lines to skip over the fold in the paper.
247: Thus,
248: .P1
249: pr junk temp
250: .P2
251: will print
252: .UL junk
253: neatly,
254: then skip to the top of a new page and print
255: .UL temp
256: neatly.
257: .PP
258: .UL pr
259: can also produce multi-column output:
260: .P1
261: pr -3 junk
262: .P2
263: prints
264: .UL junk
265: in 3-column format.
266: You can use any reasonable number in place of ``3''
267: and
268: .UL pr
269: will do its best.
270: .UL pr
271: has other capabilities as well;
272: see
273: .UL pr (1).
274: .PP
275: It should be noted that
276: .UL pr
277: is
278: .ul
279: not
280: a formatting program in the sense of shuffling lines around
281: and justifying margins.
282: The true formatters are
283: .UL nroff
284: and
285: .UL troff ,
286: which we will get to in the section on document preparation.
287: .PP
288: There are also programs that print files
289: on a high-speed printer.
290: Look in your manual under
291: .UL opr
292: and
293: .UL lpr .
294: Which to use depends on
295: what equipment is attached to your machine.
296: .SH
297: Shuffling Files About
298: .PP
299: Now that you have some files in the file system
300: and some experience in printing them,
301: you can try bigger things.
302: For example,
303: you can move a file from one place to another
304: (which amounts to giving it a new name),
305: like this:
306: .P1
307: mv junk precious
308: .P2
309: This means that what used to be ``junk'' is now ``precious''.
310: If you do an
311: .UL ls
312: command now,
313: you will get
314: .P1
315: precious
316: temp
317: .P2
318: Beware that if you move a file to another one
319: that already exists,
320: the already existing contents are lost forever.
321: .PP
322: If you want
323: to make a
324: .ul
325: copy
326: of a file (that is, to have two versions of something),
327: you can use the
328: .UL cp
329: command:
330: .P1
331: cp precious temp1
332: .P2
333: makes a duplicate copy of
334: .UL precious
335: in
336: .UL temp1 .
337: .PP
338: Finally, when you get tired of creating and moving
339: files,
340: there is a command to remove files from the file system,
341: called
342: .UL rm .
343: .P1
344: rm temp temp1
345: .P2
346: will remove both of the files named.
347: .PP
348: You will get a warning message if one of the named files wasn't there,
349: but otherwise
350: .UL rm ,
351: like most
352: .UC UNIX
353: commands,
354: does its work silently.
355: There is no prompting or chatter,
356: and error messages are occasionally curt.
357: This terseness is sometimes disconcerting
358: to new\%comers,
359: but experienced users find it desirable.
360: .SH
361: What's in a Filename
362: .PP
363: So far we have used filenames without ever saying what's
364: a legal name,
365: so it's time for a couple of rules.
366: First, filenames are limited to 14 characters,
367: which is enough to be descriptive.\(dg
368: .FS
369: \(dg In 4.2 BSD the limit was extended to 255 characters.
370: .FE
371: Second, although you can use almost any character
372: in a filename,
373: common sense says you should stick to ones that are visible,
374: and that you should probably avoid characters that might be used
375: with other meanings.
376: We have already seen, for example,
377: that in the
378: .UL ls
379: command,
380: .UL ls\ \-t
381: means to list in time order.
382: So if you had a file whose name
383: was
384: .UL \-t ,
385: you would have a tough time listing it by name.
386: Besides the minus sign, there are other characters which
387: have special meaning.
388: To avoid pitfalls,
389: you would do well to
390: use only letters, numbers and the period
391: until you're familiar with the situation.
392: .PP
393: On to some more positive suggestions.
394: Suppose you're typing a large document
395: like a book.
396: Logically this divides into many small pieces,
397: like chapters and perhaps sections.
398: Physically it must be divided too,
399: for
400: .UL ed
401: will not handle really big files.
402: Thus you should type the document as a number of files.
403: You might have a separate file for each chapter,
404: called
405: .P1
406: chap1
407: chap2
408: .ft R
409: etc...
410: .P2
411: Or, if each chapter were broken into several files, you might have
412: .P1
413: chap1.1
414: chap1.2
415: chap1.3
416: \&...
417: chap2.1
418: chap2.2
419: \&...
420: .P2
421: You can now tell at a glance where a particular file fits into the whole.
422: .PP
423: There are advantages to a systematic naming convention which are not obvious
424: to the novice
425: .UC UNIX
426: user.
427: What if you wanted to print the whole book?
428: You could say
429: .P1
430: pr chap1.1 chap1.2 chap1.3 ......
431: .P2
432: but you would get tired pretty fast, and would probably even make mistakes.
433: Fortunately, there is a shortcut.
434: You can say
435: .P1
436: pr chap*
437: .P2
438: The
439: .UL *
440: means ``anything at all,''
441: so this translates into ``print all files
442: whose names begin with
443: .UL chap '',
444: listed in alphabetical order.
445: .PP
446: This shorthand notation
447: is not a property of the
448: .UL pr
449: command, by the way.
450: It is system-wide, a service of the program
451: that interprets commands
452: (the ``shell,''
453: .UL sh (1)).
454: Using that fact, you can see how to list the names of the files in the book:
455: .P1
456: ls chap*
457: .P2
458: produces
459: .P1
460: chap1.1
461: chap1.2
462: chap1.3
463: \&...
464: .P2
465: The
466: .UL *
467: is not limited to the last position in a filename \(em
468: it can be anywhere
469: and can occur several times.
470: Thus
471: .P1
472: rm *junk* *temp*
473: .P2
474: removes all files that contain
475: .UL junk
476: or
477: .UL temp
478: as any part of their name.
479: As a special case,
480: .UL *
481: by itself matches every filename,
482: so
483: .P1
484: pr *
485: .P2
486: prints all your files
487: (alphabetical order),
488: and
489: .P1
490: rm *
491: .P2
492: removes
493: .ul
494: all files.
495: (You had better be
496: .IT very
497: sure that's what you wanted to say!)
498: .PP
499: The
500: .UL *
501: is not
502: the only pattern-matching feature available.
503: Suppose you want to print only chapters 1 through 4 and 9.
504: Then you can say
505: .P1
506: pr chap[12349]*
507: .P2
508: The
509: .UL [...]
510: means to match any of the characters inside the brackets.
511: A range of consecutive letters or digits can be abbreviated,
512: so you can also do this
513: with
514: .P1
515: pr chap[1-49]*
516: .P2
517: Letters can also be used within brackets:
518: .UL [a\-z]
519: matches any character in the range
520: .UL a
521: through
522: .UL z .
523: .PP
524: The
525: .UL ?
526: pattern matches any single character,
527: so
528: .P1
529: ls ?
530: .P2
531: lists all files which have single-character names,
532: and
533: .P1
534: ls -l chap?.1
535: .P2
536: lists information about the first file of each chapter
537: .UL chap1.1 \&, (
538: .UL chap2.1 ,
539: etc.).
540: .PP
541: Of these niceties,
542: .UL *
543: is certainly the most useful,
544: and you should get used to it.
545: The others are frills, but worth knowing.
546: .PP
547: If you should ever have to turn off the special meaning
548: of
549: .UL * ,
550: .UL ? ,
551: etc.,
552: enclose the entire argument in single quotes,
553: as in
554: .P1
555: ls \(fm?\(fm
556: .P2
557: We'll see some more examples of this shortly.
558: .SH
559: What's in a Filename, Continued
560: .PP
561: When you first made that file called
562: .UL junk ,
563: how did
564: the system
565: know that there wasn't another
566: .UL junk
567: somewhere else,
568: especially since the person in the next office is also
569: reading this tutorial?
570: The answer is that generally each user
571: has a private
572: .IT directory ,
573: which contains only the files that belong to him.
574: When you log in, you are ``in'' your directory.
575: Unless you take special action,
576: when you create a new file,
577: it is made in the directory that you are currently in;
578: this is most often your own directory,
579: and thus the file is unrelated to any other file of the same name
580: that might exist in someone else's directory.
581: .PP
582: The set of all files
583: is organized into a (usually big) tree,
584: with your files located several branches into the tree.
585: It is possible for you to ``walk'' around this tree,
586: and to find any file in the system, by starting at the root
587: of the tree and walking along the proper set of branches.
588: Conversely, you can start where you are and walk toward the root.
589: .PP
590: Let's try the latter first.
591: The basic tools is the command
592: .UL pwd
593: (``print working directory''),
594: which prints the name of the directory you are currently in.
595: .PP
596: Although the details will vary according to the system you are on,
597: if you give the
598: command
599: .UL pwd ,
600: it will print something like
601: .P1
602: /usr/your\(hyname
603: .P2
604: This says that you are currently in the directory
605: .UL your-name ,
606: which is in turn in the directory
607: .UL /usr ,
608: which is in turn in the root directory
609: called by convention just
610: .UL / .
611: (Even if it's not called
612: .UL /usr
613: on your system,
614: you will get something analogous.
615: Make the corresponding mental adjustment and read on.)
616: .PP
617: If you now type
618: .P1
619: ls /usr/your\(hyname
620: .P2
621: you should get exactly the same list of file names
622: as you get from a plain
623: .UL ls :
624: with no arguments,
625: .UL ls
626: lists the contents of the current directory;
627: given the name of a directory,
628: it lists the contents of that directory.
629: .PP
630: Next, try
631: .P1
632: ls /usr
633: .P2
634: This should print a long series of names,
635: among which is your own login name
636: .UL your-name .
637: On many systems,
638: .UL usr
639: is a directory that contains the directories
640: of all the normal users of the system,
641: like you.
642: .PP
643: The next step is to try
644: .P1
645: ls /
646: .P2
647: You should get a response something like this
648: (although again the details may be different):
649: .P1
650: bin
651: dev
652: etc
653: lib
654: tmp
655: usr
656: .P2
657: This is a collection of the basic directories of files
658: that
659: the system
660: knows about;
661: we are at the root of the tree.
662: .PP
663: Now try
664: .P1
665: cat /usr/your\(hyname/junk
666: .P2
667: (if
668: .UL junk
669: is still around in your directory).
670: The name
671: .P1
672: /usr/your\(hyname/junk
673: .P2
674: is called the
675: .UL pathname
676: of the file that
677: you normally think of as ``junk''.
678: ``Pathname'' has an obvious meaning:
679: it represents the full name of the path you have to follow from the root
680: through the tree of directories to get to a particular file.
681: It is a universal rule in
682: the
683: .UC UNIX
684: system
685: that anywhere you can use an ordinary filename,
686: you can use a pathname.
687: .PP
688: Here is a picture which may make this clearer:
689: .P1 1
690: .ft R
691: .if t .vs 9p
692: .if t .tr /\(sl
693: .if t .tr ||
694: .ce 100
695: (root)
696: / | \e
697: / | \e
698: / | \e
699: bin etc usr dev tmp
700: / | \e / | \e / | \e / | \e / | \e
701: / | \e
702: / | \e
703: adam eve mary
704: / / \e \e
705: / \e junk
706: junk temp
707: .ce 0
708: .br
709: .tr //
710: .P2
711: .LP
712: Notice that Mary's
713: .UL junk
714: is unrelated to Eve's.
715: .PP
716: This isn't too exciting if all the files of interest are in your own
717: directory, but if you work with someone else
718: or on several projects concurrently,
719: it becomes handy indeed.
720: For example, your friends can print your book by saying
721: .P1
722: pr /usr/your\(hyname/chap*
723: .P2
724: Similarly, you can find out what files your neighbor has
725: by saying
726: .P1
727: ls /usr/neighbor\(hyname
728: .P2
729: or make your own copy of one of his files by
730: .P1
731: cp /usr/your\(hyneighbor/his\(hyfile yourfile
732: .P2
733: .PP
734: If your neighbor doesn't want you poking around in his files,
735: or vice versa,
736: privacy can be arranged.
737: Each file and directory has read-write-execute permissions for the owner,
738: a group, and everyone else,
739: which can be set
740: to control access.
741: See
742: .UL ls (1)
743: and
744: .UL chmod (1)
745: for details.
746: As a matter of observed fact,
747: most users most of the time find openness of more
748: benefit than privacy.
749: .PP
750: As a final experiment with pathnames, try
751: .P1
752: ls /bin /usr/bin
753: .P2
754: Do some of the names look familiar?
755: When you run a program, by typing its name after the prompt character,
756: the system simply looks for a file of that name.
757: It normally looks first in your directory
758: (where it typically doesn't find it),
759: then in
760: .UL /bin
761: and finally in
762: .UL /usr/bin .
763: There is nothing magic about commands like
764: .UL cat
765: or
766: .UL ls ,
767: except that they have been collected into a couple of places to be easy to find and administer.
768: .PP
769: What if you work regularly with someone else on common information
770: in his directory?
771: You could just log in as your friend each time you want to,
772: but you can also say
773: ``I want to work on his files instead of my own''.
774: This is done by changing the directory that you are
775: currently in:
776: .P1
777: cd /usr/your\(hyfriend
778: .P2
779: (On some systems,
780: .UL cd
781: is spelled
782: .UL chdir .)
783: Now when you use a filename in something like
784: .UL cat
785: or
786: .UL pr ,
787: it refers to the file in your friend's directory.
788: Changing directories doesn't affect any permissions associated
789: with a file \(em
790: if you couldn't access a file from your own directory,
791: changing to another directory won't alter that fact.
792: Of course,
793: if you forget what directory you're in, type
794: .P1
795: pwd
796: .P2
797: to find out.
798: .PP
799: It is usually convenient to arrange your own files
800: so that all the files related to one thing are in a directory separate
801: from other projects.
802: For example, when you write your book, you might want to keep all the text
803: in a directory called
804: .UL book .
805: So make one with
806: .P1
807: mkdir book
808: .P2
809: then go to it with
810: .P1
811: cd book
812: .P2
813: then start typing chapters.
814: The book is now found in (presumably)
815: .P1
816: /usr/your\(hyname/book
817: .P2
818: To remove the directory
819: .UL book ,
820: type
821: .P1
822: rm book/*
823: rmdir book
824: .P2
825: The first command removes all files from the directory;
826: the second
827: removes the empty directory.
828: .PP
829: You can go up one level in the tree of files
830: by saying
831: .P1
832: cd ..
833: .P2
834: .UL .. '' ``
835: is the name of the parent of whatever directory you are currently in.
836: For completeness,
837: .UL . '' ``
838: is an alternate name
839: for the directory you are in.
840: .SH
841: Using Files instead of the Terminal
842: .PP
843: Most of the commands we have seen so far produce output
844: on the terminal;
845: some, like the editor, also take their input from the terminal.
846: It is universal in
847: .UC UNIX
848: systems
849: that the terminal can be replaced by a file
850: for either or both of input and output.
851: As one example,
852: .P1
853: ls
854: .P2
855: makes a list of files on your terminal.
856: But if you say
857: .P1
858: ls >filelist
859: .P2
860: a list of your files will be placed in the file
861: .UL filelist
862: (which
863: will be created if it doesn't already exist,
864: or overwritten if it does).
865: The symbol
866: .UL >
867: means ``put the output on the following file,
868: rather than on the terminal.''
869: Nothing is produced on the terminal.
870: As another example, you could combine
871: several files into one by capturing the output of
872: .UL cat
873: in a file:
874: .P1
875: cat f1 f2 f3 >temp
876: .P2
877: .PP
878: The symbol
879: .UL >>
880: operates very much like
881: .UL >
882: does,
883: except that it means
884: ``add to the end of.''
885: That is,
886: .P1
887: cat f1 f2 f3 >>temp
888: .P2
889: means to concatenate
890: .UL f1 ,
891: .UL f2
892: and
893: .UL f3
894: to the end of whatever is already in
895: .UL temp ,
896: instead of overwriting the existing contents.
897: As with
898: .UL > ,
899: if
900: .UL temp
901: doesn't exist, it will be created for you.
902: .PP
903: In a similar way, the symbol
904: .UL <
905: means to take the input
906: for a program from the following file,
907: instead of from the terminal.
908: Thus, you could make up a script of commonly used editing commands
909: and put them into a file called
910: .UL script .
911: Then you can run the script on a file by saying
912: .P1
913: ed file <script
914: .P2
915: As another example, you can use
916: .UL ed
917: to prepare a letter in file
918: .UL let ,
919: then send it to several people with
920: .P1
921: mail adam eve mary joe <let
922: .P2
923: .SH
924: Pipes
925: .PP
926: One of the novel contributions of
927: the
928: .UC UNIX
929: system
930: is the idea of a
931: .ul
932: pipe.
933: A pipe is simply a way to connect the output of one program
934: to the input of another program,
935: so the two run as a sequence of processes \(em
936: a pipeline.
937: .PP
938: For example,
939: .P1
940: pr f g h
941: .P2
942: will print the files
943: .UL f ,
944: .UL g ,
945: and
946: .UL h ,
947: beginning each on a new page.
948: Suppose you want
949: them run together instead.
950: You could say
951: .P1
952: cat f g h >temp
953: pr <temp
954: rm temp
955: .P2
956: but this is more work than necessary.
957: Clearly what we want is to take the output of
958: .UL cat
959: and
960: connect it to the input of
961: .UL pr .
962: So let us use a pipe:
963: .P1
964: cat f g h | pr
965: .P2
966: The vertical bar
967: .UL |
968: means to
969: take the output from
970: .UL cat ,
971: which would normally have gone to the terminal,
972: and put it into
973: .UL pr
974: to be neatly formatted.
975: .PP
976: There are many other examples of pipes.
977: For example,
978: .P1
979: ls | pr -3
980: .P2
981: prints a list of your files in three columns.
982: The program
983: .UL wc
984: counts the number of lines, words and characters in
985: its input, and as we saw earlier,
986: .UL who
987: prints a list of currently-logged on people,
988: one per line.
989: Thus
990: .P1
991: who | wc
992: .P2
993: tells how many people are logged on.
994: And of course
995: .P1
996: ls | wc
997: .P2
998: counts your files.
999: .PP
1000: Any program
1001: that reads from the terminal
1002: can read from a pipe instead;
1003: any program that writes on the terminal can drive
1004: a pipe.
1005: You can have as many elements in a pipeline as you wish.
1006: .PP
1007: Many
1008: .UC UNIX
1009: programs are written so that they will take their input from one or more files
1010: if file arguments are given;
1011: if no arguments are given they will read from the terminal,
1012: and thus can be used in pipelines.
1013: .UL pr
1014: is one example:
1015: .P1
1016: pr -3 a b c
1017: .P2
1018: prints files
1019: .UL a ,
1020: .UL b
1021: and
1022: .UL c
1023: in order in three columns.
1024: But in
1025: .P1
1026: cat a b c | pr -3
1027: .P2
1028: .UL pr
1029: prints the information coming down the pipeline,
1030: still in
1031: three columns.
1032: .SH
1033: The Shell
1034: .PP
1035: We have already mentioned once or twice the mysterious
1036: ``shell,''
1037: which is in fact
1038: .UL sh (1).\(dg
1039: .FS
1040: \(dg On Berkeley Unix systems, the usual shell for interactive use is the c shell,
1041: .UL csh(1).
1042: .FE
1043: The shell is the program that interprets what you type as
1044: commands and arguments.
1045: It also looks after translating
1046: .UL * ,
1047: etc.,
1048: into lists of filenames,
1049: and
1050: .UL < ,
1051: .UL > ,
1052: and
1053: .UL |
1054: into changes of input and output streams.
1055: .PP
1056: The shell has other capabilities too.
1057: For example, you can run two programs with one command line
1058: by separating the commands with a semicolon;
1059: the shell recognizes the semicolon and
1060: breaks the line into two commands.
1061: Thus
1062: .P1
1063: date; who
1064: .P2
1065: does both commands before returning with a prompt character.
1066: .PP
1067: You can also have more than one program running
1068: .ul
1069: simultaneously
1070: if you wish.
1071: For example, if you are doing something time-consuming,
1072: like the editor script
1073: of an earlier section,
1074: and you don't want to wait around for the results before starting something else,
1075: you can say
1076: .P1
1077: ed file <script &
1078: .P2
1079: The ampersand at the end of a command line
1080: says ``start this command running,
1081: then take further commands from the terminal immediately,''
1082: that is,
1083: don't wait for it to complete.
1084: Thus the script will begin,
1085: but you can do something else at the same time.
1086: Of course, to keep the output from interfering
1087: with what you're doing on the terminal,
1088: it would be better to say
1089: .P1
1090: ed file <script >script.out &
1091: .P2
1092: which saves the output lines in a file
1093: called
1094: .UL script.out .
1095: .PP
1096: When you initiate a command with
1097: .UL & ,
1098: the system
1099: replies with a number
1100: called the process number,
1101: which identifies the command in case you later want
1102: to stop it.
1103: If you do, you can say
1104: .P1
1105: kill process\(hynumber
1106: .P2
1107: If you forget the process number,
1108: the command
1109: .UL ps
1110: will tell you about everything you have running.
1111: (If you are desperate,
1112: .UL kill\ 0
1113: will kill all your processes.)
1114: And if you're curious about other people,
1115: .UL ps\ a
1116: will tell you about
1117: .ul
1118: all
1119: programs that are currently running.
1120: .PP
1121: You can say
1122: .P1 1
1123: (command\(hy1; command\(hy2; command\(hy3) &
1124: .P2
1125: to start three commands in the background,
1126: or you can start a background pipeline with
1127: .P1
1128: command\(hy1 | command\(hy2 &
1129: .P2
1130: .PP
1131: Just as you can tell the editor
1132: or some similar program to take its input
1133: from a file instead of from the terminal,
1134: you can tell the shell to read a file
1135: to get commands.
1136: (Why not? The shell, after all, is just a program,
1137: albeit a clever one.)
1138: For instance, suppose you want to set tabs on
1139: your terminal, and find out the date
1140: and who's on the system every time you log in.
1141: Then you can put the three necessary commands
1142: .UL tabs , (
1143: .UL date ,
1144: .UL who )
1145: into a file, let's call it
1146: .UL startup ,
1147: and then run it with
1148: .P1
1149: sh startup
1150: .P2
1151: This says to run the shell with the file
1152: .UL startup
1153: as input.
1154: The effect is as if you had typed
1155: the contents of
1156: .UL startup
1157: on the terminal.
1158: .PP
1159: If this is to be a regular thing,
1160: you can eliminate the
1161: need to type
1162: .UL sh :
1163: simply type, once only, the command
1164: .P1
1165: chmod +x startup
1166: .P2
1167: and thereafter you need only say
1168: .P1
1169: startup
1170: .P2
1171: to run the sequence of commands.
1172: The
1173: .UL chmod (1)
1174: command marks the file executable;
1175: the shell recognizes this and runs it as a sequence of commands.
1176: .PP
1177: If you want
1178: .UL startup
1179: to run automatically every time you log in,
1180: create a file in your login directory called
1181: .UL .profile ,
1182: and place in it the line
1183: .UL startup .
1184: When the shell first gains control when you log in,
1185: it looks for the
1186: .UL .profile
1187: file and does whatever commands it finds in it.\(dg
1188: .FS
1189: \(dg The c shell instead reads a file called
1190: .UL .login
1191: .
1192: .FE
1193: We'll get back to the shell in the section
1194: on programming.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.