Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ED(1)                                                       ED(1)

NAME
       ed - text editor

SYNOPSIS
       ed [-] [-sx] [-p string] [file]

DESCRIPTION
       ed  is a line-oriented text editor.  It is used to create,
       display, modify and otherwise manipulate text files.

       If invoked with a file argument, then 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 are
       lost.

       Editing 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.  A typical
       command might look like:

              ,s/old/new/g

       which replaces all occurences of the string old with  new.

       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.  Lines consist of
       text up to and including a newline character.  Input  mode
       is  terminated by entering a single period  (.) on a line.

       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 example
       above.  However even here, the `s' command is  applied  to
       whole lines at a time.

       In  general,  ed  commands  consist  of  zero or more line
       addresses, followed by a single character command and pos-
       sibly  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  sup-
       plied.

                           21 May 1993                          1

ED(1)                                                       ED(1)

   OPTIONS
       -s      Suppresses  diagnostics.  This  should  be used if
               ed's standard input is from a script.

       -x      Prompts for an encryption key to be used in subse-
               quent reads and writes (see the `x' command).

       -p string
               Specifies  a  command prompt.  This may be toggled
               on and off with the `P' command.

       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, pre-
               fix  the  name  with a backslash (\).  The default
               filename is set to file only if it is not prefixed
               with a bang.

   LINE ADDRESSING
       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 semi-colon. 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

                           21 May 1993                          2

ED(1)                                                       ED(1)

       relative  to  the  current  address.   In  a   semi-colon-
       delimited range, the first address is used to set the cur-
       rent address, and the second address is interpreted  rela-
       tive to the first.

       The following address symbols are recognized.

       .       The current line (address) in the buffer.

       $       The last line in the buffer.

       n       The nth, line in the buffer where n is a number in
               the range [0,$].

       - or ^  The previous line.  This is equivalent to  -1  and
               may be repeated with cumulative effect.

       -n or ^n
               The  nth  previous line, where n is a non-negative
               number.

       +       The next line.  This is equivalent to +1  and  may
               be repeated with cumulative effect.

       +n or whitespacen
               The  nth next line, where n is a non-negative num-
               ber.  whitespace followed by a number n is  inter-
               preted as +n.

       , or %  The  first through last lines in the buffer.  This
               is equivalent to the address range 1,$.

       ;       The current through  last  lines  in  the  buffer.
               This is equivalent to the address range .,$.

       /re/    The  next  line  containing the regular expression
               re.  The search wraps  to  the  beginning  of  the
               buffer  and continues down to the current line, if
               necessary.  // repeats the last search.

       ?re?    The previous line containing the  regular  expres-
               sion  re.   The  search  wraps  to  the end of the

                           21 May 1993                          3

ED(1)                                                       ED(1)

               buffer and continues up to the  current  line,  if
               necessary.  ?? repeats the last search.

       'lc     The  line  previously  marked by a `k' (mark) com-
               mand, where lc is a lower case letter.

   REGULAR EXPRESSIONS
       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 correspond-
       ing 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       Any  character  c not listed below, including `{',
               '}', `(', `)', `<' and `>', matches itself.

       \c      Any backslash-escaped character c, except for `{',
               '}', `(', `)', `<' and `>', matches itself.

       Matches any single character.

       [char-class]
               Matches  any  single  character in char-class.  To
               include a  `]' in char-class, it must be the first
               character.  A range of characters may be specified
               by separating the end characters of the range with
               a  `-', e.g., `a-z' specifies the lower case char-
               acters.  The  following  literal  expressions  can
               also  be  used  in  char-class  to specify sets of
               characters:

                 [:alnum:]  [:cntrl:]  [:lower:]  [:space:]
                 [:alpha:]  [:digit:]  [:print:]  [:upper:]
                 [:blank:]  [:graph:]  [:punct:]  [:xdigit:]

                           21 May 1993                          4

ED(1)                                                       ED(1)

               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.] or,   [=col-elm=]

               where col-elm is a collating  element  are  inter-
               preted  according to locale(5) (not currently sup-
               ported).  See regex(3) for an explanation of these
               constructs.

       [^char-class]
               Matches  any single character, other than newline,
               not  in  char-class.   char-class  is  defined  as
               above.

       ^       If `^' is the first character of a regular expres-
               sion, then it anchors the  regular  expression  to
               the  beginning  of  a line.  Otherwise, it matches
               itself.

       $       If `$' is the last character of a regular  expres-
               sion, it anchors the regular expression to the end
               of a line.  Otherwise, it matches itself.

       \<      Anchors the single character regular expression or
               subexpression  immediately  following  it  to  the
               beginning of a word.  (This may not be available)

       \>      Anchors the single character regular expression or
               subexpression  immediately following it to the end
               of a word.  (This may not be available)

       \(re\)  Defines a subexpression re.  Subexpressions may be
               nested.   A  subsequent  backreference of the form
               `\n', where n is a  number  in  the  range  [1,9],
               expands  to the text matched by the nth subexpres-
               sion.   For  example,   the   regular   expression
               `\(.*\)\1'  matches any string consisting of iden-
               tical  adjacent  substrings.   Subexpressions  are
               ordered relative to their left delimiter.

       *       Matches the single character regular expression or
               subexpression immediately  preceding  it  zero  or
               more  times.   If  '*' is the first character of a
               regular  expression  or  subexpression,  then   it
               matches itself.  The `*' operator sometimes yields
               unexpected  results.   For  example,  the  regular
               expression  `b*'  matches  the  beginning  of  the
               string `abbb' (as opposed to the substring `bbb'),
               since a null match is the only left-most match.

                           21 May 1993                          5

ED(1)                                                       ED(1)

       \{n,m\} or \{n,\} or \{n\}
               Matches the single character regular expression or
               subexpression immediately preceding it at least  n
               and  at  most  m  times.  If m is omitted, then it
               matches at least n times.  If the  comma  is  also
               omitted, then it matches exactly n times.

       Additional  regular  expression  operators  may be defined
       depending on the particular regex(3) implementation.

   COMMANDS
       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.  How-
       ever, 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    Appends text to the  buffer  after  the  addressed
               line.  Text is entered in input mode.  The current
               address is set to last line entered.

       (.,.)c  Changes lines in the buffer.  The addressed  lines
               are  deleted from the buffer, and text is appended
               in their place.  Text is entered  in  input  mode.
               The current address is set to last line entered.

       (.,.)d  Deletes  the  addressed lines from the buffer.  If
               there is a line after the deleted range, then  the
               current address is set to this line. Otherwise the
               current address is set  to  the  line  before  the
               deleted range.

       e file  Edits  file,  and  sets  the default filename.  If
               file is not specified, then the  default  filename
               is  used.   Any  lines  in  the buffer are deleted
               before the new file is read.  The current  address
               is set to the last line read.

       e !command
               Edits  the  standard  output  of  `!command', (see
               !command  below).    The   default   filename   is
               unchanged.   Any  lines  in the buffer are deleted
               before the output of command is read.  The current

                           21 May 1993                          6

ED(1)                                                       ED(1)

               address is set to the last line read.

       E file  Edits  file  unconditionally.   This is similar to
               the e command, except that unwritten  changes  are
               discarded without warning.  The current address is
               set to the last line read.

       f file  Sets the default filename to file.  If file is not
               specified,  then the default unescaped filename is
               printed.

       (1,$)g/re/command-list
               Applies command-list  to  each  of  the  addressed
               lines  matching a regular expression re.  The cur-
               rent address is set to the line currently  matched
               before  command-list  is  executed.  At the end of
               the `g' command, the current address is set to the
               last line affected by command-list.

               Each command in command-list must be on a separate
               line, and every line except for the last  must  be
               terminated  by  a backslash (\).  Any commands are
               allowed, except for `g', `G',  `v',  and  `V'.   A
               newline  alone  in command-list is equivalent to a
               `p' command.

       (1,$)G/re/
               Interactively edits the addressed lines matching a
               regular  expression  re.   For each matching line,
               the line is printed, the current address  is  set,
               and  the user is prompted to enter a command-list.
               At the end of the `G' command, the current address
               is  set  to  the  last line affected by (the last)
               command-list.

               The format of command-list is the same as that  of
               the  `g'  command.  A newline alone acts as a null
               command list.  A single `&' repeats the last  non-
               null command list.

       H       Toggles  the  printing  of error explanations.  By
               default, explanations are not printed.  It is rec-
               ommended  that  ed scripts begin with this command
               to aid in debugging.

       h       Prints an explanation of the last error.

       (.)i    Inserts text in  the  buffer  before  the  current
               line.  Text is entered in input mode.  The current
               address is set to the last line entered.

       (.,.+1)j
               Joins the addressed lines.   The  addressed  lines
               are  deleted  from  the  buffer  and replaced by a

                           21 May 1993                          7

ED(1)                                                       ED(1)

               single line containing  their  joined  text.   The
               current address is set to the resultant line.

       (.)klc  Marks  a  line  with  a lower case letter lc.  The
               line can then be addressed as 'lc (i.e., a  single
               quote  followed  by  lc  ) in subsequent commands.
               The mark is not cleared until the line is  deleted
               or otherwise modified.

       (.,.)l  Prints  the  addressed  lines unambiguously.  If a
               single line fills for than one screen (as might be
               the   case   when   viewing  a  binary  file,  for
               instance), a `--More--' prompt is printed  on  the
               last  line.   ed  waits  until  the  RETURN key is
               pressed before displaying the  next  screen.   The
               current address is set to the last line printed.

       (.,.)m(.)
               Moves  lines  in  the buffer.  The addressed lines
               are moved  to  after  the  right-hand  destination
               address,  which  may be the address 0 (zero).  The
               current address is set to the last line moved.

       (.,.)n  Prints the addressed lines along with  their  line
               numbers.   The  current address is set to the last
               line printed.

       (.,.)p  Prints the addressed lines. The current address is
               set to the last line printed.

       P       Toggles  the  command prompt on and off.  Unless a
               prompt was specified by with  command-line  option
               -p string, the command prompt is by default turned
               off.

       q       Quits ed.

       Q       Quits ed unconditionally.  This is similar to  the
               q  command, except that unwritten changes are dis-
               carded without warning.

       ($)r file
               Reads file to after the addressed line.   If  file
               is  not  specified,  then  the default filename is
               used.  If there was no default filename  prior  to
               the  command,  then the default filename is set to
               file.   Otherwise,   the   default   filename   is
               unchanged.  The current address is set to the last
               line read.

       ($)r !command
               Reads to after the  addressed  line  the  standard
               output  of  `!command',  (see the !command below).
               The default filename is  unchanged.   The  current

                           21 May 1993                          8

ED(1)                                                       ED(1)

               address is set to the last line read.

       (.,.)s/re/replacement/
       (.,.)s/re/replacement/g
       (.,.)s/re/replacement/n
               Replaces  text  in  the addressed lines matching a
               regular  expression  re  with   replacement.    By
               default,  only  the  first  match  in each line is
               replaced.  If the `g' (global)  suffix  is  given,
               then  every match to be replaced.  The `n' suffix,
               where n is a postive number, causes only  the  nth
               match  to  be replaced.  It is an error if no sub-
               stitutions are performed on any of  the  addressed
               lines.   The  current address is set the last line
               affected.

               re and replacement may be delimited by any charac-
               ter other than space and newline (see the `s' com-
               mand below).  If one or two of the last delimiters
               is omitted, then the last line affected is printed
               as though the print suffix `p' were specified.

               An unescaped `&' in replacement is replaced by the
               currently  matched  text.   The character sequence
               `\m', where m is a number in the range  [1,9],  is
               replaced  by  the  mth backreference expression of
               the matched text.  If replacement  consists  of  a
               single `%', then replacement from the last substi-
               tution is  used.   Newlines  may  be  embedded  in
               replacement  if  they are escaped with a backslash
               (\).

       (.,.)s  Repeats the last substitution.  This form  of  the
               `s'  command  accepts  a  count suffix `n', or any
               combination of the characters `r', `g',  and  `p'.
               If  a count suffix `n' is given, then only the nth
               match is replaced.  The `r' suffix causes the reg-
               ular  expression  of  the  last  search to be used
               instead of the that of the last substitution.  The
               `g'  suffix  toggles the global suffix of the last
               substitution.  The `p' suffix  toggles  the  print
               suffix   of  the  last  substitution  The  current
               address is set to the last line affected.

       (.,.)t(.)
               Copies (i.e., transfers) the  addressed  lines  to
               after  the  right-hand  destination address, which
               may be the address 0 (zero).  The current  address
               is set to the last line copied.

       u       Undoes  the  last command and restores the current
               address to what it was before  the  command.   The
               global  commands  `g',  `G',  `v',  and  `V'.  are

                           21 May 1993                          9

ED(1)                                                       ED(1)

               treated as a single command by undo.  `u'  is  its
               own inverse.

       (1,$)v/pat/command-list
               Applies  command-list  to  each  of  the addressed
               lines not matching a regular expression re.   This
               is similar to the `g' command.

       (1,$)V/re/
               Interactively edits the addressed lines not match-
               ing a regular expression re.  This is  similar  to
               the `G' command.

       (1,$)w file
               Writes  the addressed lines to file.  Any previous
               contents of file  is  lost  without  warning.   If
               there  is  no  default  filename, then the default
               filename  is  set  to  file,   otherwise   it   is
               unchanged.   If no filename is specified, then the
               default filename is used.  The current address  is
               unchanged.

       (1,$)wq file
               Writes  the addressed lines to file, and then exe-
               cutes a `q' command.

       (1,$)w !command
               Writes the addressed lines to the  standard  input
               of  `!command',  (see  the  !command  below).  The
               default   filename   and   current   address   are
               unchanged.

       (1,$)W file
               Appends  the  addressed  lines to the end of file.
               This is similar to the `w'  command,  expect  that
               the  previous  contents  of file is not clobbered.
               The current address is unchanged.

       x       Prompts for an encryption key  which  is  used  in
               subsequent  reads  and writes.  If a newline alone
               is entered as the key, then encryption  is  turned
               off.   Otherwise,  echoing is disabled while a key
               is read.  Encryption/decryption is done using  the
               bdes(1) algorithm.

       (.+1)zn Scrolls  n  lines  at a time starting at addressed
               line.  If n is not  specified,  then  the  current
               window  size  is used.  The current address is set
               to the last line printed.

       !command
               Executes command via sh(1).  If the first  charac-
               ter of command is `!', then it is replaced by text
               of the previous `!command'.  ed does  not  process

                           21 May 1993                         10

ED(1)                                                       ED(1)

               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.

       ($)=    Prints the line number of the addressed line.

       (.+1)newline
               Prints  the  addressed  line, and sets the current
               address to that line.

FILES
       /tmp/ed.*           Buffer file
       ed.hup              The file to which ed attempts to write
                           the   buffer if the terminal hangs up.

SEE ALSO
       vi(1), sed(1), regex(3), bdes(1), sh(1).

       USD:12-13

       B. W. Kernighan and P. J. Plauger, Software Tools in  Pas-
       cal , Addison-Wesley, 1981.

LIMITATIONS
       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

DIAGNOSTICS
       When an error occurs, ed prints a `?' and  either  returns
       to  command  mode  or exits if its input is from a script.
       An explanation of the last error can be printed  with  the
       `h' (help) command.

       Since  the  `g'  (global)  command   masks any errors from
       failed searches and substitutions, it can be used to  per-
       form conditional operations in scripts; e.g.,

              g/old/s//new/

       replaces  any  occurrences  of  old  with new.  If the `u'
       (undo) command occurs in a global command list,  then  the
       command list is executed only once.

       If  diagnostics are not disabled, attempting to quit ed or

                           21 May 1993                         11

ED(1)                                                       ED(1)

       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.

                           21 May 1993                         12


NAME | SYNOPSIS | DESCRIPTION | FILES | SEE ALSO | LIMITATIONS | DIAGNOSTICS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=ed&sektion=1&manpath=NetBSD+1.0>

home | help