GNU Info

(ed.info)Intro

---

Next: Invoking ed Prev: Top Up: Top

---

Enter node , (file) or (file)node

Intro
*****

   `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 returns `ed' to command mode.
     # Now write the buffer to the file `sonnet' and quit:
     w sonnet
     183
     # `ed' reports 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 Note: Invoking 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 Note: 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.