The Datafile PD-CD 4/DATAFILE_PDCD4.iso/unix/riscbsd/1_1_contri/usd/13_edadv/ae6

Text File | 1986-06-05 | 9.6 KB | 495 lines

.\"    @(#)ae6    6.1 (Berkeley) 6/5/86
.\"
.NH
CUT AND PASTE WITH THE EDITOR
.PP
Now we move on to manipulating pieces of files _
individual lines or groups of lines.
This is another area where new users seem
unsure of themselves.
.SH
Filenames
.PP
The first step is to ensure that you know the
.UL ed
commands for reading and writing files.
Of course you can't go very far without knowing
.UL r
and
.UL w .
Equally useful, but less well known, is the `edit' command
.UL e .
Within
.UL ed ,
the command
.P1
e  newfile
.P2
says `I want to edit a new file called
.ul
newfile,
without leaving the editor.'
The
.UL e
command discards whatever you're currently working on
and starts over on
.ul
newfile.
It's exactly the same as if you had quit with the
.UL q
command, then re-entered
.UL ed
with a new file name,
except that if you have a pattern remembered, then a command
like
.UL //
will still work.
.PP
If you enter
.UL ed
with the command
.P1
ed  file
.P2
.UL ed
remembers the name of the file,
and any subsequent
.UL e ,
.UL r
or
.UL w
commands that don't contain a filename
will refer to this remembered file.
Thus
.P1 2
.ta .5i .6i .7i
ed  file1
 ... (editing) ...
w    (writes back in file1)
e  file2    (edit new file, without leaving editor)
 ... (editing on file2) ...
w    (writes back on file2)
.P2
(and so on) does a series of edits on various files
without ever leaving
.UL ed
and without typing the name of any file more than once.
(As an aside, if you examine the sequence of commands here,
you can see why many
UNIX
systems use
.UL e
as a synonym
for
.UL ed .)
.PP
You can find out the remembered file name at any time
with the
.UL f
command;
just type
.UL f
without a file name.
You can also change the name of the remembered file name with
.UL f ;
a useful sequence is
.P1
ed  precious
f  junk
 ... (editing) ...
.P2
which gets a copy of a precious file,
then uses
.UL f
to guarantee that a careless
.UL w
command won't clobber the original.
.SH
Inserting One File into Another
.PP
Suppose you have a file called
`memo',
and you want the file called
`table'
to be inserted just after the reference to
Table 1.
That is, in
`memo'
somewhere is a line that says
.IP
Table 1 shows that ...
.LP
and the data contained in
`table'
has to go there,
probably so it will be formatted
properly by
.UL nroff
or
.UL troff .
Now what?
.PP
This one is easy.
Edit
`memo',
find
`Table 1',
and add the file
`table'
right there:
.P1
ed  memo
/Table 1/
.ft I
Table 1 shows that ... [response from ed]
.ft
\&\*.r  table
.P2
The critical line is the last one.
As we said earlier, the
.UL r
command reads a file;
here you asked for it to be read in right after
line dot.
An
.UL r
command without any address
adds lines at the end,
so it is the same as
.UL $r .
.SH
Writing out Part of a File
.PP
The other side of the coin is writing out part of
the document you're editing.
For example, maybe
you want to copy out into a separate file
that table from the previous example,
so it can be formatted and tested separately.
Suppose that in the file being edited
we have
.P1
\&\*.TS
 ...[lots of stuff]
\&\*.TE
.P2
which is the way a table is set up for the
.UL tbl
program.
To isolate
the table
in a separate file called
`table',
first find the start of the table
(the `.TS' line), then write out the interesting part:
.P1
/^\*e\*.TS/
.ft I
\&\*.TS  [ed prints the line it found]
.ft R
\&\*.,/^\*e\*.TE/w table
.P2
and the job is done.
If you are confident, you can do it all at once with
.P1
/^\*e\*.TS/;/^\*e\*.TE/w table
.P2
and now you have two copies, one in the file you're still editing,
one in the file `table' you've just written.
.PP
The point is that the
.UL w
command can
write out a group of lines, instead of the whole file.
In fact, you can write out a single line if you like;
just give one line number instead of two.
For example, if you have just typed a horribly complicated line
and you know that it (or something like it) is going to be needed later,
then save it _ don't re-type it.
In the editor, say
.P1
a
\&...lots of stuff...
\&...horrible line...
\&\*.
\&\*.w  temp
a
\&\*.\*.\*.more stuff\*.\*.\*.
\&\*.
\&\*.r temp
a
\&\*.\*.\*.more stuff\*.\*.\*.
\&\*.
.P2
This last example is worth studying, to be sure you appreciate
what's going on.
.SH
Moving Lines Around
.PP
Suppose you want to
move a paragraph from its present position in a paper
to the end.
How would you do it?
As a concrete example, suppose each paragraph in the paper
begins with the formatting command
`.PP'.
Think about it and write down the details before reading on.
.PP
The brute force way
(not necessarily bad)
is to write the paragraph onto a temporary file,
delete it from its current position,
then read in the temporary file at the end.
Assuming that you are sitting on the
`.PP' command that begins
the paragraph, this is the sequence of commands:
.P1
\&\*.,/^\*e\*.PP/-w temp
\&\*.,//-d
$r temp
.P2
That is, from where you are now
(`\*.')
until one line before the next `\*.PP'
(`/^\*e\*.PP/\-')
write onto
`temp'.
Then delete the same lines.
Finally, read
`temp'
at the end.
.PP
As we said, that's the brute force way.
The easier way (often)
is to use the
.ul
move
command
.UL m
that
.UL ed
provides _
it lets you do the whole set of operations
at one crack,
without any temporary file.
.PP
The
.UL m
command
is like many other
.UL ed
commands in that it takes up to two line numbers in front
that tell what lines are to be affected.
It is also
.ul
followed
by a line number that tells where the lines are to go.
Thus
.P1
line1, line2 m line3
.P2
says to move all the lines between
`line1'
and
`line2'
after
`line3'.
Naturally, any of
`line1'
etc., can be patterns between slashes,
$
signs, or other ways to specify lines.
.PP
Suppose again that you're sitting at the first line of the
paragraph.
Then you can say
.P1
\&\*.,/^\*e\*.PP/-m$
.P2
That's all.
.PP
As another example of a frequent operation,
you can reverse the order of two adjacent lines
by moving the first one
to after the second.
Suppose that you are positioned at the first.
Then
.P1
m+
.P2
does it.
It says to move line dot to after one line after line dot.
If you are positioned on the second line,
.P1
m--
.P2
does the interchange.
.PP
As you can see, the
.UL m
command is more succinct and direct than
writing, deleting and re-reading.
When is brute force better anyway?
This is a matter of personal taste _
do what you have most confidence in.
The main difficulty with the
.UL m
command
is that if you use patterns to specify both the lines
you are moving and the target,
you have to take care that you specify them properly,
or you may well not move the lines you thought you did.
The result of a botched
.UL m
command can be a ghastly mess.
Doing the job a step at a time
makes it easier for you to verify at each step
that you accomplished what you wanted to.
It's also a good idea to issue a
.UL w
command
before doing anything complicated;
then if you goof, it's easy to back up
to where you were.
.SH
Marks
.PP
.UL ed
provides a facility for marking a line
with a particular name so you can later reference it
by name
regardless of its actual line number.
This can be handy for moving lines,
and for keeping track of them even after they've been moved.
The
.ul
mark
command is
.UL k ;
the command
.P1
kx
.P2
marks the current line with the name `x'.
If a line number precedes the
.UL k ,
that line is marked.
(The mark name must be a single lower case letter.)
Now you can refer to the marked line with the address
.P1
\(fmx
.P2
.PP
Marks are most useful for moving things around.
Find the first line of the block to be moved, and mark it
with
.ul
\(fma.
Then find the last line and mark it with
.ul
\(fmb.
Now position yourself at the place where the stuff is to go
and say
.P1
\(fma,\(fmbm\*.
.P2
.PP
Bear in mind that only one line can have a particular
mark name associated with it
at any given time.
.SH
Copying Lines
.PP
We mentioned earlier the idea of saving a line
that was hard to type or used often,
so as to cut down on typing time.
Of course this could be more than one line;
then the saving is presumably even greater.
.PP
.UL ed
provides another command,
called
.UL t
(for `transfer')
for making a copy of a group of one or more lines
at any point.
This is often easier than writing and reading.
.PP
The
.UL t
command is identical to the
.UL m
command, except that instead of moving lines
it simply duplicates them at the place you named.
Thus
.P1
1,$t$
.P2
duplicates the entire contents that you are editing.
A more common use for
.UL t
is for creating a series of lines that differ only slightly.
For example, you can say
.P1
.ta 1i
a
\&..........  x  ......... (long line)
\&\*.
t\*.    (make a copy)
s/x/y/    (change it a bit)
t\*.    (make third copy)
s/y/z/    (change it a bit)
.P2
and so on.
.SH
The Temporary Escape `!'
.PP
Sometimes it is convenient to be able
to temporarily escape from the editor to do
some other
.UX
command,
perhaps one of the file copy or move commands
discussed in section 5,
without leaving the editor.
The `escape' command
.UL !
provides a way to do this.
.PP
If you say
.P1
!any UNIX command
.P2
your current editing state is suspended,
and the
.UX
command you asked for is executed.
When the command finishes,
.UL ed
will signal you by printing another
.UL ! ;
at that point you can resume editing.
.PP
You can really do
.ul
any
.UX
command, including another
.UL ed .
(This is quite common, in fact.)
In this case, you can even do another
.UL ! .
.PP
On Berkeley
.UX
systems, there is an additional (and preferable) mechanism called
.ul
job control
which lets you suspend your edit session (or, for that matter,
any program), return to the shell from
which you invoked that program, and issue any commands, then resume
the program from the point where it was stopped.  See
.ul
An Introduction to the C Shell
for more details.