Research V6 development

[unix-history] / usr / doc / ed / e4

.H1
Exercise 5:
.H2
.PG
Experiment with the substitute command.
See what happens if you
substitute for some word on a line with several occurrences of that word.
For example, do this:
.X1
a
the other side of the coin
.li
\fB.\fR
s/the/on the/p
.X2
You will get
.X1
on the other side of the coin
.X2
A substitute command changes only the first occurrence of the first string.
You can change all occurrences by adding a ``g'' (for ``global'')
to the ``s'' command, like this:
.X1
s/ . . . / . . . /gp
.X2
Try other characters instead of slashes to delimit the two sets
of characters in the ``s'' command \(mi anything should work
except blanks or tabs.
.PG
(If you get funny results using any of the characters
.X1
^    \*.    $    [    *    \\
.X2
read the section on ``Special Characters''.)
.H1
Context searching \(mi ``/ . . . /''
.H2
.PG
With the substitute command mastered, we can move on to
another highly important idea of
.ul
ed
\(mi context searching.
.PG
Suppose we have our original three line text in the buffer:
.X1
Now is the time
for all good men
to come to the aid of their party.
.X2
Suppose we want to find the line that contains ``their'' so
we can change it to ``the''.
Now with only three lines in the buffer, it's pretty easy
to keep track of what line the word ``their'' is on.
But if the buffer contained several hundred lines,
and we'd been making changes, deleting and rearranging lines,
and so on, we would no longer really know what this line
number would be.
Context searching is simply a method of specifying the desired line,
regardless of what its number is,
by specifying some context on it.
.PG
The way we say ``search for a line
that contains this particular string of characters''
is to type
.X1
/\fIstring of characters we want to find\fP/
.X2
For example,
the
.ul
ed
line
.X1
/their/
.X2
is a context search which
is sufficient to find the desired line \(mi
it will locate the next occurrence of
the characters between slashes (``their'').
It also sets dot to that line
and prints the line for verification:
.X1
to come to the aid of their party.
.X2
``Next occurrence'' means that
.ul
ed
starts looking for the string at line ``\*.+1'',
searches to the end of the buffer,
then continues at line 1 and searches to line dot.
(That is, the search ``wraps around'' from ``$'' to 1.) 
It scans all the lines in the buffer until it either finds the desired line
or gets back to dot again.
If the given string of characters can't be found in any line,
.ul
ed
types the error message
.X1
?
.X2
Otherwise it prints the line it found.
.PG
We can do both the search for the desired line
.ul
and
a
substitution all at once, like this:
.X1
/their/s/their/the/p
.X2
which will yield
.X1
to come to the aid of the party.
.X2
There were three parts to that last command:
context search for the desired line, make the substitution, print the line.
.PG
The expression ``/their/'' is a context search expression.
In their simplest form,
all context search expressions are like this \(mi
a string of characters surrounded by slashes.
Context searches are interchangeable with line numbers,
so they can be used by themselves to find and print a desired line,
or as line numbers for some other command, like ``s''.
We used them both ways in the examples above.
.PG
Suppose the buffer contains the three familiar lines
.X1
Now is the time
for all good men
to come to the aid of their party.
.X2
Then the
.ul
ed
line numbers
.X1
/Now/+1
/good/
/party/\(mi1
.X2
are all context search expressions, and they all refer
to the same line (line 2).
To make a change in line 2,
we could say
.X1
/Now/+1s/good/bad/
.X2
or
.X1
/good/s/good/bad/
.X2
or
.X1
/party/\(mi1s/good/bad/
.X2
The choice is dictated only by convenience.
We could print all three lines by, for instance
.X1
/Now/,/party/p
.X2
or
.X1
/Now/,/Now/+2p
.X2
or by any number of similar combinations.
The first one of these might be better if we don't
know how many lines are involved.
(Of course, if there were only three lines in the buffer,
we'd use
.X1
1,$p
.X2
but not if there were several hundred.)
.PG
The basic rule is: a context search expression is
.ul
the same as
a line number, so it can be used wherever a line number is needed.
.H1
Exercise 6:
.H2
.PG
Experiment with context searching.
Try a body of text with
several occurrences
of the same string of characters, and scan through it using
the same context search.
.PG
Try using context searches as line numbers for the
substitute, print and delete commands.
(They can also be used
with ``r'', ``w'', and ``a''.)
.PG
Try context searching using ``?text?'' instead of ``/text/''.
This scans lines in the buffer in reverse order
rather than normal.
This is
sometimes useful if you go too far while looking for some
string of characters \(mi it's an easy way to back up.
.PG
(If you get funny results with any of the characters
.X1
^    \*.    $    [    *    \\
.X2
read the section on ``Special Characters''.)
.PG
.ul
Ed
provides a shorthand for repeating a context search
for the same string.
For example,
the
.ul
ed
line number
.X1
/string/
.X2
will find the next occurrence of ``string''.
It often happens that this is not the desired line,
so the search must be repeated.
This can be done by typing merely
.X1
//
.X2
This shorthand stands for ``the most recently used
context search expression.''
It can
also be used as the first string of the substitute
command, as in
.X1
/string1/s//string2/
.X2
which will find the next occurrence of ``string1''
and replace it by ``string2''.
This can save a lot of typing.
Similarly
.X1
??
.X2
means ``scan backwards for the same expression.''