![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ae2 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 / 13.edadv|
Return to ae2 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 13.edadv |
1.1 root 1: .\" @(#)ae2 6.1 (Berkeley) 5/22/86
2: .\"
3: .NH
4: SPECIAL CHARACTERS
5: .PP
6: The editor
7: .UL ed
8: is the primary interface to the system
9: for many people, so
10: it is worthwhile to know
11: how to get the most out of
12: .UL ed
13: for the least effort.
14: .PP
15: The next few sections will discuss
16: shortcuts
17: and labor-saving devices.
18: Not all of these will be instantly useful
19: to any one person, of course,
20: but a few will be,
21: and the others should give you ideas to store
22: away for future use.
23: And as always,
24: until you try these things,
25: they will remain theoretical knowledge,
26: not something you have confidence in.
27: .SH
28: The List command `l'
29: .PP
30: .UL ed
31: provides two commands for printing the contents of the lines
32: you're editing.
33: Most people are familiar with
34: .UL p ,
35: in combinations like
36: .P1
37: 1,$p
38: .P2
39: to print all the lines you're editing,
40: or
41: .P1
42: s/abc/def/p
43: .P2
44: to change
45: `abc'
46: to
47: `def'
48: on the current line.
49: Less familiar is the
50: .ul
51: list
52: command
53: .UL l
54: (the letter `\fIl\|\fR'),
55: which gives slightly more information than
56: .UL p .
57: In particular,
58: .UL l
59: makes visible characters that are normally invisible,
60: such as tabs and backspaces.
61: If you list a line that contains some of these,
62: .UL l
63: will print each tab as
64: .UL \z\(mi>
65: and each backspace as
66: .UL \z\(mi< .\(dg
67: .FS
68: \(dg These composite characters are created by overstriking a minus
69: and a > or <, so they only appear as < or > on display terminals.
70: .FE
71: This makes it much easier to correct the sort of typing mistake
72: that inserts extra spaces adjacent to tabs,
73: or inserts a backspace followed by a space.
74: .PP
75: The
76: .UL l
77: command
78: also `folds' long lines for printing _
79: any line that exceeds 72 characters is printed on multiple lines;
80: each printed line except the last is terminated by a backslash
81: .UL \*e ,
82: so you can tell it was folded.
83: This is useful for printing long lines on short terminals.
84: .PP
85: Occasionally the
86: .UL l
87: command will print in a line a string of numbers preceded by a backslash,
88: such as \*e07 or \*e16.
89: These combinations are used to make visible characters that normally don't print,
90: like form feed or vertical tab or bell.
91: Each such combination is a single character.
92: When you see such characters, be wary _
93: they may have surprising meanings when printed on some terminals.
94: Often their presence means that your finger slipped while you were typing;
95: you almost never want them.
96: .SH
97: The Substitute Command `s'
98: .PP
99: Most of the next few sections will be taken up with a discussion
100: of the
101: substitute
102: command
103: .UL s .
104: Since this is the command for changing the contents of individual
105: lines,
106: it probably has the most complexity of any
107: .UL ed
108: command,
109: and the most potential for effective use.
110: .PP
111: As the simplest place to begin,
112: recall the meaning of a trailing
113: .UL g
114: after a substitute command.
115: With
116: .P1
117: s/this/that/
118: .P2
119: and
120: .P1
121: s/this/that/g
122: .P2
123: the
124: first
125: one replaces the
126: .ul
127: first
128: `this' on the line
129: with `that'.
130: If there is more than one `this' on the line,
131: the second form
132: with the trailing
133: .UL g
134: changes
135: .ul
136: all
137: of them.
138: .PP
139: Either form of the
140: .UL s
141: command can be followed by
142: .UL p
143: or
144: .UL l
145: to `print' or `list' (as described in the previous section)
146: the contents of the line:
147: .P1
148: s/this/that/p
149: s/this/that/l
150: s/this/that/gp
151: s/this/that/gl
152: .P2
153: are all legal, and mean slightly different things.
154: Make sure you know what the differences are.
155: .PP
156: Of course, any
157: .UL s
158: command can be preceded by one or two `line numbers'
159: to specify that the substitution is to take place
160: on a group of lines.
161: Thus
162: .P1
163: 1,$s/mispell/misspell/
164: .P2
165: changes the
166: .ul
167: first
168: occurrence of
169: `mispell' to `misspell' on every line of the file.
170: But
171: .P1
172: 1,$s/mispell/misspell/g
173: .P2
174: changes
175: .ul
176: every
177: occurrence in every line
178: (and this is more likely to be what you wanted in this
179: particular case).
180: .PP
181: You should also notice that if you add a
182: .UL p
183: or
184: .UL l
185: to the end of any of these substitute commands,
186: only the last line that got changed will be printed,
187: not all the lines.
188: We will talk later about how to print all the lines
189: that were modified.
190: .SH
191: The Undo Command `u'
192: .PP
193: Occasionally you will make a substitution in a line,
194: only to realize too late that it was a ghastly mistake.
195: The `undo' command
196: .UL u
197: lets you `undo' the last substitution:
198: the last line that was substituted can be restored to
199: its previous state by typing the command
200: .P1
201: u
202: .P2
203: .SH
204: The Metacharacter `\*.'
205: .PP
206: As you have undoubtedly noticed
207: when you use
208: .UL ed ,
209: certain characters have unexpected meanings
210: when they occur in the left side of a substitute command,
211: or in a search for a particular line.
212: In the next several sections, we will talk about
213: these special characters,
214: which are often called `metacharacters'.
215: .PP
216: The first one is the period `\*.'.
217: On the left side of a substitute command,
218: or in a search with `/.../',
219: `\*.' stands for
220: .ul
221: any
222: single character.
223: Thus the search
224: .P1
225: /x\*.y/
226: .P2
227: finds any line where `x' and `y' occur separated by
228: a single character, as in
229: .P1
230: x+y
231: x\-y
232: x\*(BLy
233: x\*.y
234: .P2
235: and so on.
236: (We will use \*(BL to stand for a space whenever we need to
237: make it visible.)
238: .PP
239: Since `\*.' matches a single character,
240: that gives you a way to deal with funny characters
241: printed by
242: .UL l .
243: Suppose you have a line that, when printed with the
244: .UL l
245: command, appears as
246: .P1
247: .... th\*e07is ....
248: .P2
249: and you want to get rid of the
250: \*e07
251: (which represents the bell character, by the way).
252: .PP
253: The most obvious solution is to try
254: .P1
255: s/\*e07//
256: .P2
257: but this will fail. (Try it.)
258: The brute force solution, which most people would now take,
259: is to re-type the entire line.
260: This is guaranteed, and is actually quite a reasonable tactic
261: if the line in question isn't too big,
262: but for a very long line,
263: re-typing is a bore.
264: This is where the metacharacter `\*.' comes in handy.
265: Since `\*e07' really represents a single character,
266: if we say
267: .P1
268: s/th\*.is/this/
269: .P2
270: the job is done.
271: The `\*.' matches the mysterious character between the `h' and the `i',
272: .ul
273: whatever it is.
274: .PP
275: Bear in mind that since `\*.' matches any single character,
276: the command
277: .P1
278: s/\*./,/
279: .P2
280: converts the first character on a line into a `,',
281: which very often is not what you intended.
282: .PP
283: As is true of many characters in
284: .UL ed ,
285: the `\*.' has several meanings, depending
286: on its context.
287: This line shows all three:
288: .P1
289: \&\*.s/\*./\*./
290: .P2
291: The first `\*.' is a line number,
292: the number of
293: the line we are editing,
294: which is called `line dot'.
295: (We will discuss line dot more in Section 3.)
296: The second `\*.' is a metacharacter
297: that matches any single character on that line.
298: The third `\*.' is the only one that really is
299: an honest literal period.
300: On the
301: .ul
302: right
303: side of a substitution, `\*.'
304: is not special.
305: If you apply this command to the line
306: .P1
307: Now is the time\*.
308: .P2
309: the result will
310: be
311: .P1
312: \&\*.ow is the time\*.
313: .P2
314: which is probably not what you intended.
315: .SH
316: The Backslash `\*e'
317: .PP
318: Since a period means `any character',
319: the question naturally arises of what to do
320: when you really want a period.
321: For example, how do you convert the line
322: .P1
323: Now is the time\*.
324: .P2
325: into
326: .P1
327: Now is the time?
328: .P2
329: The backslash `\*e' does the job.
330: A backslash turns off any special meaning that the next character
331: might have; in particular,
332: `\*e\*.' converts the `\*.' from a `match anything'
333: into a period, so
334: you can use it to replace
335: the period in
336: .P1
337: Now is the time\*.
338: .P2
339: like this:
340: .P1
341: s/\*e\*./?/
342: .P2
343: The pair of characters `\*e\*.' is considered by
344: .UL ed
345: to be a single real period.
346: .PP
347: The backslash can also be used when searching for lines
348: that contain a special character.
349: Suppose you are looking for a line that contains
350: .P1
351: \&\*.PP
352: .P2
353: The search
354: .P1
355: /\*.PP/
356: .P2
357: isn't adequate, for it will find
358: a line like
359: .P1
360: THE APPLICATION OF ...
361: .P2
362: because the `\*.' matches the letter `A'.
363: But if you say
364: .P1
365: /\*e\*.PP/
366: .P2
367: you will find only lines that contain `\*.PP'.
368: .PP
369: The backslash can also be used to turn off special meanings for
370: characters other than `\*.'.
371: For example, consider finding a line that contains a backslash.
372: The search
373: .P1
374: /\*e/
375: .P2
376: won't work,
377: because the `\*e' isn't a literal `\*e', but instead means that the second `/'
378: no longer \%delimits the search.
379: But by preceding a backslash with another one,
380: you can search for a literal backslash.
381: Thus
382: .P1
383: /\*e\*e/
384: .P2
385: does work.
386: Similarly, you can search for a forward slash `/' with
387: .P1
388: /\*e//
389: .P2
390: The backslash turns off the meaning of the immediately following `/' so that
391: it doesn't terminate the /.../ construction prematurely.
392: .PP
393: As an exercise, before reading further, find two substitute commands each of which will
394: convert the line
395: .P1
396: \*ex\*e\*.\*ey
397: .P2
398: into the line
399: .P1
400: \*ex\*ey
401: .P2
402: .PP
403: Here are several solutions;
404: verify that each works as advertised.
405: .P1
406: s/\*e\*e\*e\*.//
407: s/x\*.\*./x/
408: s/\*.\*.y/y/
409: .P2
410: .PP
411: A couple of miscellaneous notes about
412: backslashes and special characters.
413: First, you can use any character to delimit the pieces
414: of an
415: .UL s
416: command: there is nothing sacred about slashes.
417: (But you must use slashes for context searching.)
418: For instance, in a line that contains a lot of slashes already, like
419: .P1
420: //exec //sys.fort.go // etc...
421: .P2
422: you could use a colon as the delimiter _
423: to delete all the slashes, type
424: .P1
425: s:/::g
426: .P2
427: .PP
428: Second, if # and @ are your character erase and line kill characters,
429: you have to type \*e# and \*e@;
430: this is true whether you're talking to
431: .UL ed
432: or any other program.
433: .PP
434: When you are adding text with
435: .UL a
436: or
437: .UL i
438: or
439: .UL c ,
440: backslash is not special, and you should only put in
441: one backslash for each one you really want.
442: .SH
443: The Dollar Sign `$'
444: .PP
445: The next metacharacter, the `$', stands for `the end of the line'.
446: As its most obvious use, suppose you have the line
447: .P1
448: Now is the
449: .P2
450: and you wish to add the word `time' to the end.
451: Use the $ like this:
452: .P1
453: s/$/\*(BLtime/
454: .P2
455: to get
456: .P1
457: Now is the time
458: .P2
459: Notice that a space is needed before `time' in
460: the substitute command,
461: or you will get
462: .P1
463: Now is thetime
464: .P2
465: .PP
466: As another example, replace the second comma in
467: the following line with a period without altering the first:
468: .P1
469: Now is the time, for all good men,
470: .P2
471: The command needed is
472: .P1
473: s/,$/\*./
474: .P2
475: The $ sign here provides context to make specific which comma we mean.
476: Without it, of course, the
477: .UL s
478: command would operate on the first comma to produce
479: .P1
480: Now is the time\*. for all good men,
481: .P2
482: .PP
483: As another example, to convert
484: .P1
485: Now is the time\*.
486: .P2
487: into
488: .P1
489: Now is the time?
490: .P2
491: as we did earlier, we can use
492: .P1
493: s/\*.$/?/
494: .P2
495: .PP
496: Like `\*.', the `$'
497: has multiple meanings depending on context.
498: In the line
499: .P1
500: $s/$/$/
501: .P2
502: the first `$' refers to the
503: last line of the file,
504: the second refers to the end of that line,
505: and the third is a literal dollar sign,
506: to be added to that line.
507: .SH
508: The Circumflex `^'
509: .PP
510: The circumflex (or hat or caret)
511: `^' stands for the beginning of the line.
512: For example, suppose you are looking for a line that begins
513: with `the'.
514: If you simply say
515: .P1
516: /the/
517: .P2
518: you will in all likelihood find several lines that contain `the' in the middle before
519: arriving at the one you want.
520: But with
521: .P1
522: /^the/
523: .P2
524: you narrow the context, and thus arrive at the desired one
525: more easily.
526: .PP
527: The other use of `^' is of course to enable you to insert
528: something at the beginning of a line:
529: .P1
530: s/^/\*(BL/
531: .P2
532: places a space at the beginning of the current line.
533: .PP
534: Metacharacters can be combined. To search for a
535: line that contains
536: .ul
537: only
538: the characters
539: .P1
540: \&\*.PP
541: .P2
542: you can use the command
543: .P1
544: /^\*e\*.PP$/
545: .P2
546: .SH
547: The Star `*'
548: .PP
549: Suppose you have a line that looks like this:
550: .P1
551: \fItext \fR x y \fI text \fR
552: .P2
553: where
554: .ul
555: text
556: stands
557: for lots of text,
558: and there are some indeterminate number of spaces between the
559: .UL x
560: and the
561: .UL y .
562: Suppose the job is to replace all the spaces between
563: .UL x
564: and
565: .UL y
566: by a single space.
567: The line is too long to retype, and there are too many spaces
568: to count.
569: What now?
570: .PP
571: This is where the metacharacter `*'
572: comes in handy.
573: A character followed by a star
574: stands for as many consecutive occurrences of that
575: character as possible.
576: To refer to all the spaces at once, say
577: .P1
578: s/x\*(BL*y/x\*(BLy/
579: .P2
580: The construction
581: `\*(BL*'
582: means
583: `as many spaces as possible'.
584: Thus `x\*(BL*y' means `an x, as many spaces as possible, then a y'.
585: .PP
586: The star can be used with any character, not just space.
587: If the original example was instead
588: .P1
589: \fItext \fR x--------y \fI text \fR
590: .P2
591: then all `\-' signs can be replaced by a single space
592: with the command
593: .P1
594: s/x-*y/x\*(BLy/
595: .P2
596: .PP
597: Finally, suppose that the line was
598: .P1
599: \fItext \fR x\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.y \fI text \fR
600: .P2
601: Can you see what trap lies in wait for the unwary?
602: If you blindly type
603: .P1
604: s/x\*.*y/x\*(BLy/
605: .P2
606: what will happen?
607: The answer, naturally, is that it depends.
608: If there are no other x's or y's on the line,
609: then everything works, but it's blind luck, not good management.
610: Remember that `\*.' matches
611: .ul
612: any
613: single character?
614: Then `\*.*' matches as many single characters as possible,
615: and unless you're careful, it can eat up a lot more of the line
616: than you expected.
617: If the line was, for example, like this:
618: .P1
619: \fItext \fRx\fI text \fR x\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.\*.y \fI text \fRy\fI text \fR
620: .P2
621: then saying
622: .P1
623: s/x\*.*y/x\*(BLy/
624: .P2
625: will take everything from the
626: .ul
627: first
628: `x' to the
629: .ul
630: last
631: `y',
632: which, in this example, is undoubtedly more than you wanted.
633: .PP
634: The solution, of course, is to turn off the special meaning of
635: `\*.' with
636: `\*e\*.':
637: .P1
638: s/x\*e\*.*y/x\*(BLy/
639: .P2
640: Now everything works, for `\*e\*.*' means `as many
641: .ul
642: periods
643: as possible'.
644: .PP
645: There are times when the pattern `\*.*' is exactly what you want.
646: For example, to change
647: .P1
648: Now is the time for all good men ....
649: .P2
650: into
651: .P1
652: Now is the time\*.
653: .P2
654: use `\*.*' to eat up everything after the `for':
655: .P1
656: s/\*(BLfor\*.*/\*./
657: .P2
658: .PP
659: There are a couple of additional pitfalls associated with `*' that you should be aware of.
660: Most notable is the fact that `as many as possible' means
661: .ul
662: zero
663: or more.
664: The fact that zero is a legitimate possibility is
665: sometimes rather surprising.
666: For example, if our line contained
667: .P1
668: \fItext \fR xy \fI text \fR x y \fI text \fR
669: .P2
670: and we said
671: .P1
672: s/x\*(BL*y/x\*(BLy/
673: .P2
674: the
675: .ul
676: first
677: `xy' matches this pattern, for it consists of an `x',
678: zero spaces, and a `y'.
679: The result is that the substitute acts on the first `xy',
680: and does not touch the later one that actually contains some intervening spaces.
681: .PP
682: The way around this, if it matters, is to specify a pattern like
683: .P1
684: /x\*(BL\*(BL*y/
685: .P2
686: which says `an x, a space, then as many more spaces as possible, then a y',
687: in other words, one or more spaces.
688: .PP
689: The other startling behavior of `*' is again related to the fact
690: that zero is a legitimate number of occurrences of something
691: followed by a star. The command
692: .P1
693: s/x*/y/g
694: .P2
695: when applied to the line
696: .P1
697: abcdef
698: .P2
699: produces
700: .P1
701: yaybycydyeyfy
702: .P2
703: which is almost certainly not what was intended.
704: The reason for this behavior is that zero is a legal number
705: of matches,
706: and there are no x's at the beginning of the line
707: (so that gets converted into a `y'),
708: nor between the `a' and the `b'
709: (so that gets converted into a `y'), nor ...
710: and so on.
711: Make sure you really want zero matches;
712: if not, in this case write
713: .P1
714: s/xx*/y/g
715: .P2
716: `xx*' is one or more x's.
717: .SH
718: The Brackets `[ ]'
719: .PP
720: Suppose that you want to delete any numbers
721: that appear
722: at the beginning of all lines of a file.
723: You might first think of trying a series of commands like
724: .P1
725: 1,$s/^1*//
726: 1,$s/^2*//
727: 1,$s/^3*//
728: .P2
729: and so on,
730: but this is clearly going to take forever if the numbers are at all long.
731: Unless you want to repeat the commands over and over until
732: finally all numbers are gone,
733: you must get all the digits on one pass.
734: This is the purpose of the brackets [ and ].
735: .PP
736: The construction
737: .P1
738: [0123456789]
739: .P2
740: matches any single digit _
741: the whole thing is called a `character class'.
742: With a character class, the job is easy.
743: The pattern `[0123456789]*' matches zero or more digits (an entire number), so
744: .P1
745: 1,$s/^[0123456789]*//
746: .P2
747: deletes all digits from the beginning of all lines.
748: .PP
749: Any characters can appear within a character class,
750: and just to confuse the issue there are essentially no special characters
751: inside the brackets;
752: even the backslash doesn't have a special meaning.
753: To search for special characters, for example, you can say
754: .P1
755: /[\*.\*e$^[]/
756: .P2
757: Within [...], the `[' is not special.
758: To get a `]' into a character class,
759: make it the first character.
760: .PP
761: It's a nuisance to have to spell out the digits,
762: so you can abbreviate them as
763: [0\-9];
764: similarly, [a\-z] stands for the lower case letters,
765: and
766: [A\-Z] for upper case.
767: .PP
768: As a final frill on character classes, you can specify a class
769: that means `none of the following characters'.
770: This is done by beginning the class with a `^':
771: .P1
772: [^0-9]
773: .P2
774: stands for `any character
775: .ul
776: except
777: a digit'.
778: Thus you might find the first line that doesn't begin with a tab or space
779: by a search like
780: .P1
781: /^[^(space)(tab)]/
782: .P2
783: .PP
784: Within a character class,
785: the circumflex has a special meaning
786: only if it occurs at the beginning.
787: Just to convince yourself, verify that
788: .P1
789: /^[^^]/
790: .P2
791: finds a line that doesn't begin with a circumflex.
792: .SH
793: The Ampersand `&'
794: .PP
795: The ampersand `&' is used primarily to save typing.
796: Suppose you have the line
797: .P1
798: Now is the time
799: .P2
800: and you want to make it
801: .P1
802: Now is the best time
803: .P2
804: Of course you can always say
805: .P1
806: s/the/the best/
807: .P2
808: but it seems silly to have to repeat the `the'.
809: The `&' is used to eliminate the repetition.
810: On the
811: .ul
812: right
813: side of a substitute, the ampersand means `whatever
814: was just matched', so you can say
815: .P1
816: s/the/& best/
817: .P2
818: and the `&' will stand for `the'.
819: Of course this isn't much of a saving if the thing
820: matched is just `the', but if it is something truly long or awful,
821: or if it is something like `.*'
822: which matches a lot of text,
823: you can save some tedious typing.
824: There is also much less chance of making a typing error
825: in the replacement text.
826: For example, to parenthesize a line,
827: regardless of its length,
828: .P1
829: s/\*.*/(&)/
830: .P2
831: .PP
832: The ampersand can occur more than once on the right side:
833: .P1
834: s/the/& best and & worst/
835: .P2
836: makes
837: .P1
838: Now is the best and the worst time
839: .P2
840: and
841: .P1
842: s/\*.*/&? &!!/
843: .P2
844: converts the original line into
845: .P1
846: Now is the time? Now is the time!!
847: .P2
848: .PP
849: To get a literal ampersand, naturally the backslash is used to turn off the special meaning:
850: .P1
851: s/ampersand/\*e&/
852: .P2
853: converts the word into the symbol.
854: Notice that `&' is not special on the left side
855: of a substitute, only on the
856: .ul
857: right
858: side.
859: .SH
860: Substituting Newlines
861: .PP
862: .UL ed
863: provides a facility for splitting a single line into two or more shorter lines by `substituting in a newline'.
864: As the simplest example, suppose a line has gotten unmanageably long
865: because of editing (or merely because it was unwisely typed).
866: If it looks like
867: .P1
868: \fItext \fR xy \fI text \fR
869: .P2
870: you can break it between the `x' and the `y' like this:
871: .P1
872: s/xy/x\*e
873: y/
874: .P2
875: This is actually a single command,
876: although it is typed on two lines.
877: Bearing in mind that `\*e' turns off special meanings,
878: it seems relatively intuitive that a `\*e' at the end of
879: a line would make the newline there
880: no longer special.
881: .PP
882: You can in fact make a single line into several lines
883: with this same mechanism.
884: As a large example, consider underlining the word `very'
885: in a long line
886: by splitting `very' onto a separate line,
887: and preceding it by the
888: .UL roff
889: or
890: .UL nroff
891: formatting command `.ul'.
892: .P1
893: \fItext \fR a very big \fI text \fR
894: .P2
895: The command
896: .P1
897: s/\*(BLvery\*(BL/\*e
898: \&.ul\*e
899: very\*e
900: /
901: .P2
902: converts the line into four shorter lines,
903: preceding the word `very' by the
904: line
905: `.ul',
906: and eliminating the spaces around the `very',
907: all at the same time.
908: .PP
909: When a newline is substituted
910: in, dot is left pointing at the last line created.
911: .PP
912: .SH
913: Joining Lines
914: .PP
915: Lines may also be joined together,
916: but this is done with the
917: .UL j
918: command
919: instead of
920: .UL s .
921: Given the lines
922: .P1
923: Now is
924: \*(BLthe time
925: .P2
926: and supposing that dot is set to the first of them,
927: then the command
928: .P1
929: j
930: .P2
931: joins them together.
932: No blanks are added,
933: which is why we carefully showed a blank
934: at the beginning of the second line.
935: .PP
936: All by itself,
937: a
938: .UL j
939: command
940: joins line dot to line dot+1,
941: but any contiguous set of lines can be joined.
942: Just specify the starting and ending line numbers.
943: For example,
944: .P1
945: 1,$jp
946: .P2
947: joins all the lines into one big one
948: and prints it.
949: (More on line numbers in Section 3.)
950: .SH
951: Rearranging a Line with \*e( ... \*e)
952: .PP
953: (This section should be skipped on first reading.)
954: Recall that `&' is a shorthand that stands for whatever
955: was matched by the left side of an
956: .UL s
957: command.
958: In much the same way you can capture separate pieces
959: of what was matched;
960: the only difference is that you have to specify
961: on the left side just what pieces you're interested in.
962: .PP
963: Suppose, for instance, that
964: you have a file of lines that consist of names in the form
965: .P1
966: Smith, A. B.
967: Jones, C.
968: .P2
969: and so on,
970: and you want the initials to precede the name, as in
971: .P1
972: A. B. Smith
973: C. Jones
974: .P2
975: It is possible to do this with a series of editing commands,
976: but it is tedious and error-prone.
977: (It is instructive to figure out how it is done, though.)
978: .PP
979: The alternative
980: is to `tag' the pieces of the pattern (in this case,
981: the last name, and the initials),
982: and then rearrange the pieces.
983: On the left side of a substitution,
984: if part of the pattern is enclosed between
985: \*e( and \*e),
986: whatever matched that part is remembered,
987: and available for use on the right side.
988: On the right side,
989: the symbol `\*e1' refers to whatever
990: matched the first \*e(...\*e) pair,
991: `\*e2' to the second \*e(...\*e),
992: and so on.
993: .PP
994: The command
995: .P1
996: 1,$s/^\*e([^,]*\*e),\*(BL*\*e(\*.*\*e)/\*e2\*(BL\*e1/
997: .P2
998: although hard to read, does the job.
999: The first \*e(...\*e) matches the last name,
1000: which is any string up to the comma;
1001: this is referred to on the right side with `\*e1'.
1002: The second \*e(...\*e) is whatever follows
1003: the comma and any spaces,
1004: and is referred to as `\*e2'.
1005: .PP
1006: Of course, with any editing sequence this complicated,
1007: it's foolhardy to simply run it and hope.
1008: The global commands
1009: .UL g
1010: and
1011: .UL v
1012: discussed in section 4
1013: provide a way for you to print exactly those
1014: lines which were affected by the
1015: substitute command,
1016: and thus verify that it did what you wanted
1017: in all cases.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.