Copyright (C) 1993, 1994 Free Software Foundation, Inc.
Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.
Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.
ed is a line-oriented text editor. It is used to create,
display, modify and otherwise manipulate text files, both interactively
and via shell scripts. A restricted version of ed, red,
can only edit files in the current directory and cannot execute shell
commands. ed is the "standard" text editor in the sense that
it is the original editor for Unix, and thus widely available. For
most purposes, however, it is superceded by full-screen editors such as
Emacs and Vi.
The sample sessions below illustrate some basic concepts of line editing
with ed. We begin by creating a file, `sonnet', with some
help from Shakespeare. As with the shell, all input to ed must
be followed by a newline character. Comments begin with a `#'.
$ ed # The `a' command is for appending text to the editor buffer. a No more be grieved at that which thou hast done. Roses have thorns, and filvers foutians mud. Clouds and eclipses stain both moon and sun, And loathsome canker lives in sweetest bud. . # Entering a single period on a line returnsedto command mode. # Now write the buffer to the file `sonnet' and quit: w sonnet 183 #edreports the number of characters written. q $ ls -l total 2 -rw-rw-r-- 1 alm 183 Nov 10 01:16 sonnet $
Editing with ed is done in two distinct
modes: command and input. When first invoked, ed is
in command mode. In this mode commands are read from the standard input
and executed to manipulate the contents of the editor buffer. When an
input command, such as `a' (append), `i' (insert) or `c'
(change), is given, ed enters input mode. This is the primary
means of adding text to a file. In this mode, no commands are
available; instead, the standard input is written directly to the editor
buffer. A line consists of the text up to and including a
newline character. Input mode is terminated by
entering a single period (`.') on a line.
In the next example, some typos are corrected in the file `sonnet'.
$ ed sonnet 183 # Begin by printing the buffer to the terminal with the `p' command. # The `,' means "all lines." ,p No more be grieved at that which thou hast done. Roses have thorns, and filvers foutians mud. Clouds and eclipses stain both moon and sun, And loathsome canker lives in sweetest bud. # Select line 2 for editing. 2 Roses have thorns, and filvers foutians mud. # Use the substitute command, `s', to replace `filvers' with `silver', # and print the result. s/filvers/silver/p Roses have thorns, and silver foutians mud. # And correct the spelling of `fountains'. s/utia/untai/p Roses have thorns, and silver fountains mud. w sonnet 183 q $
ed may be invoked with or without arguments See section Invoking GNU ed. When
invoked with a file argument, a copy of file is read into
the editor's buffer. Changes are made to this copy and not directly to
file itself. Upon quitting ed, any changes not explicitly
saved with a `w' command See section Commands are lost.
Since ed is line-oriented, we have to tell it which line, or
range of lines we want to edit. In the above example, we do this by
specifying the line's number, or sequence in the buffer. Alternatively,
we could have specified a unique string in the line, e.g.,
`/filvers/', where the `/'s delimit the string in question.
Subsequent commands affect only the selected line, a.k.a. the
current line. Portions of that line are then replaced with the
substitute command, whose syntax is
`s/old/new/'.
Although ed accepts only one command per line,
the print command `p' is an exception, and may be appended to the
end of most commands.
In the next example, a title is added to our sonnet.
$ ed sonnet 183 a Sonnet #50 . ,p No more be grieved at that which thou hast done. Roses have thorns, and silver fountains mud. Clouds and eclipses stain both moon and sun, And loathsome canker lives in sweetest bud. Sonnet #50 # The title got appended to the end; we should have used `0a' # to append "before the first line." # Move the title to its proper place. 5m0p Sonnet #50 # The title is now the first line, and the current line has been # set to this line as well. ,p Sonnet #50 No more be grieved at that which thou hast done. Roses have thorns, and silver fountains mud. Clouds and eclipses stain both moon and sun, And loathsome canker lives in sweetest bud. wq sonnet 195 $
When ed opens a file, the current line is initially set to the last
line of that file. Similarly, the move command `m' sets the current
line to the last line moved.
In summary: All ed commands operate on whole lines or ranges of
lines; e.g., the `d' command deletes lines; the `m' command
moves lines, and so on. It is possible to modify only a portion of a
line by means of replacement, as in the second example above. However even
there, the `s' command is applied to whole lines at a time.
Structurally, ed commands consist of zero or more line addresses,
followed by a single character command and possibly additional
parameters; i.e., commands have the structure:
[address [,address]]command[parameters]
The address(es) indicate the line or range of lines to be affected by the command. If fewer addresses are given than the command accepts, then default addresses are supplied.
Related programs or routines are vi (1), sed (1),
regex (3), sh (1). Relevant documents
are:
Unix User's Manual Supplementary Documents: 12 -- 13
B. W. Kernighan and P. J. Plauger: "Software Tools in Pascal", Addison-Wesley, 1981.
ed
ed [-] [-Gs] [-p string] [file] red [-] [-Gs] [-p string] [file]
-G
ed
commands `G', `V', `f', `l', `m', `t'
and `!!'. If the default behavior of these commands does not seem
familiar, then try invoking ed with this switch.
-s
-
ed's standard
input is from a script.
-p string
file specifies the name of a file to read. If file is
prefixed with a bang (!), then it is interpreted as a shell command. In
this case, what is read is the standard output of file executed
via sh (1). To read a file whose name begins with a bang, prefix
the name with a backslash (\). The default filename is set to
file only if it is not prefixed with a bang.
An address represents the number of a line in the buffer. ed
maintains a current address which is typically supplied to
commands as the default address when none is specified. When a file is
first read, the current address is set to the last line of the file. In
general, the current address is set to the last line affected by a
command.
A line address is constructed from one of the bases in the list below, optionally followed by a numeric offset. The offset may include any combination of digits, operators (i.e., `+', `-' and `^') and whitespace. Addresses are read from left to right, and their values are computed relative to the current address.
One exception to the rule that addresses represent line numbers is the address `0' (zero). This means "before the first line," and is legal wherever it makes sense.
An address range is two addresses separated either by a comma or semicolon. The value of the first address in a range cannot exceed the value of the the second. If only one address is given in a range, then the second address is set to the given address. If an n-tuple of addresses is given where n > 2, then the corresponding range is determined by the last two addresses in the n-tuple. If only one address is expected, then the last address is used.
Each address in a comma-delimited range is interpreted relative to the current address. In a semicolon-delimited range, the first address is used to set the current address, and the second address is interpreted relative to the first.
The following address symbols are recognized.
.
$
n
-
^
-n
^n
+
+n
whitespace n
,
%
;
/re/
?re?
'lc
Regular expressions are patterns used in selecting text. For example,
the ed command
g/string/
prints all lines containing string. Regular expressions are also used by the `s' command for selecting old text to be replaced with new.
In addition to a specifying string literals, regular expressions can represent classes of strings. Strings thus represented are said to be matched by the corresponding regular expression. If it is possible for a regular expression to match several strings in a line, then the left-most longest match is the one selected.
The following symbols are used in constructing regular expressions:
c
\c
.
[char-class]
[:alnum:] [:cntrl:] [:lower:] [:space:] [:alpha:] [:digit:] [:print:] [:upper:] [:blank:] [:graph:] [:punct:] [:xdigit:]If `-' appears as the first or last character of char-class, then it matches itself. All other characters in char-class match themselves. Patterns in char-class of the form:
[.col-elm.] [=col-elm=]where col-elm is a collating element are interpreted according to
locale (5) (not currently supported). See
regex (3) for an explanation of these constructs.
[^char-class]
^
$
\(re\)
*
\{n,m\}
\{n,\}
\{n\}
\<
\>
The following extended operators are preceded by a backslash `\' to
distinguish them from traditional ed syntax.
\`
\'
\?
\+
\b
\B
\w
\W
All ed commands are single characters, though some require
additonal parameters. If a command's parameters extend over several
lines, then each line except for the last must be terminated with a
backslash (`\').
In general, at most one command is allowed per line. However, most commands accept a print suffix, which is any of `p' (print), `l' (list), or `n' (enumerate), to print the last line affected by the command.
An interrupt (typically ^C) has the effect of aborting the current command and returning the editor to command mode.
ed recognizes the following commands. The commands are shown
together with the default address or address range supplied if none is
specified (in parenthesis).
(.)a
(.,.)c
(.,.)d
e file
e !command
E file
f file
(1,$)g /re/command-list
ed is invoked with the
command-line option `-G', then a newline in command-list
is equivalent to a `.+1p' command.
(1,$)G /re/
H
h
(.)i
(.,.+1)j
(.)k lc
(.,.)l
ed pauses at the end of each page until a newline is entered.
The current address is set to the last line printed.
(.,.)m(.)
(.,.)n
(.,.)p
ed pauses
at the end of each page until a newline is entered.
The current address is set to the last line
printed.
P
q
ed.
Q
ed unconditionally. This is similar to the q
command, except that unwritten changes are discarded without warning.
($)r file
($)r !command
(.,.)s /re/replacement/
(.,.)s /re/replacement/g
(.,.)s /re/replacement/n
(.,.)s
(.,.)t(.)
u
(1,$)v /re/command-list
(1,$)V /re/
(1,$)w file
(1,$)wq file
(1,$)w !command
(1,$)W file
(.)x
(.,.)y
(.+1)z n
! command
sh (1). If the first character of
command is `!', then it is replaced by text of the previous
`!command'. ed does not process command for
backslash (`\') escapes. However, an unescaped `%' is
replaced by the default filename. When the shell returns from
execution, a `!' is printed to the standard output. The current
line is unchanged.
(.,.)#
($)=
(.+1)newline
The buffer files are kept in `/tmp/ed.*'. If the terminal hangs
up, ed attempts to write the buffer to file `ed.hup'.
ed processes file arguments for backslash escapes, i.e., in
a filename, any characters preceded by a backslash (`\') are
interpreted literally.
If a text (non-binary) file is not terminated by a newline character,
then ed appends one on reading/writing it. In the case of a
binary file, ed does not append a newline on reading/writing.
Per line overhead: 4 ints.
When an error occurs,
if ed's input is from a regular file or here document, then it
exits, otherwise it prints a `?' and returns to
command mode. An explanation of
the last error can be printed with the `h' (help) command.
If the `u' (undo) command occurs in a global command list, then the command list is executed only once.
Attempting to quit ed or edit
another file before writing a modified buffer results in an error. If
the command is entered a second time, it succeeds, but any changes to
the buffer are lost.
ed exits with 0 if no errors occurred; otherwise >0.