This is ed.info, produced by makeinfo version 4.13+ from ed.texi.

INFO-DIR-SECTION Basics

START-INFO-DIR-ENTRY

* Ed: (ed).                     The GNU line editor

END-INFO-DIR-ENTRY

   Copyright (C) 1993, 1994, 2006-2017 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.3 or

any later version published by the Free Software Foundation; with no

Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

?

File: ed.info,  Node: Top,  Next: Overview,  Up: (dir)

The GNU ed line editor

**********************

This manual is for GNU ed (version 1.14.2, 22 February 2017).

   GNU 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

superseded by full-screen editors such as GNU Emacs or GNU Moe.

* Menu:

* Overview::                        Overview of the 'ed' command

* Introduction to line editing::    Getting started with GNU 'ed'

* Invoking ed::                     Command line interface

* Line addressing::                 Specifying lines/ranges in the buffer

* Regular expressions::             Patterns for selecting text

* Commands::                        Commands recognized by GNU 'ed'

* Limitations::                     Intrinsic limits of GNU 'ed'

* Diagnostics::                     GNU 'ed' error handling

* Problems::                        Reporting bugs

* GNU Free Documentation License::  How you can copy and share this manual

   Copyright (C) 1993, 1994, 2006-2017 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.3 or

any later version published by the Free Software Foundation; with no

Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

?

File: ed.info,  Node: Overview,  Next: Introduction to line editing,  Prev: Top,  Up: Top

1 Overview

**********

'ed' is a line-oriented text editor. It is used to create, display,

modify and otherwise manipulate text files. 'red' is a restricted 'ed':

it can only edit files in the current directory and cannot execute

shell commands.

   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. 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.

   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 possibly additional

parameters; i.e., commands have the structure:

     [ADDRESS[,ADDRESS]]COMMAND[PARAMETERS]

   The ADDRESSes 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.

?

File: ed.info,  Node: Introduction to line editing,  Next: Invoking ed,  Prev: Overview,  Up: Top

2 Introduction to line editing

******************************

'ed' was created, along with the Unix operating system, by Ken Thompson

and Dennis Ritchie. It is the refinement of its more complex,

programmable predecessor, 'QED', to which Thompson and Ritchie had

already added pattern matching capabilities (*note Regular

expressions::).

   For the purposes of this tutorial, a working knowledge of the Unix

shell 'sh' and the Unix file system is recommended, since 'ed' is

designed to interact closely with them.  (*Note GNU bash manual:

(bash)Top, for details about bash).

   The principal difference between line editors and display editors is

that display editors provide instant feedback to user commands, whereas

line editors require sometimes lengthy input before any effects are

seen. The advantage of instant feedback, of course, is that if a mistake

is made, it can be corrected immediately, before more damage is done.

Editing in 'ed' requires more strategy and forethought; but if you are

up to the task, it can be quite efficient.

   Much of the 'ed' command syntax is shared with other Unix utilities.

   As with the shell, <RETURN> (the carriage-return key) enters a line

of input. So when we speak of "entering" a command or some text in

'ed', <RETURN> is implied at the end of each line. Prior to typing

<RETURN>, corrections to the line may be made by typing either

<BACKSPACE> to erase characters backwards, or <CONTROL>-u (i.e., hold

the CONTROL key and type u) to erase the whole line.

   When 'ed' first opens, it expects to be told what to do but doesn't

prompt us like the shell. So let's begin by telling 'ed' to do so with

the 
 ("prompt") command:

     $ ed

     P

     *

   By default, 'ed' uses asterisk ('*') as command prompt to avoid

confusion with the shell command prompt ('$').

   We can run Unix shell ('sh') commands from inside 'ed' by prefixing

them with  (exclamation mark, aka "bang"). For example:

     *!date

     Mon Jun 26 10:08:41 PDT 2006

     !

     *!for s in hello world; do echo $s; done

     hello

     world

     !

     *

   So far, this is no different from running commands in the Unix shell.

But let's say we want to edit the output of a command, or save it to a

file. First we must capture the command output to a temporary location

called a "buffer" where 'ed' can access it. This is done with 'ed''s

<r> command (mnemonic: "read"):

     *r !cal -m

     137

     *

   Here 'ed' is telling us that it has just read 137 characters into

the editor buffer - i.e., the output of the 'cal' command, which prints

a simple ASCII calendar. To display the buffer contents we issue the

 ("print") command (not to be confused with the prompt command,

which is uppercase!). To indicate the range of lines in the buffer that

should be printed, we prefix the command with <,> (comma) which is

shorthand for "the whole buffer":

     *,p

           June 2006

     Mo Tu We Th Fr Sa Su

               1  2  3  4

      5  6  7  8  9 10 11

     12 13 14 15 16 17 18

     19 20 21 22 23 24 25

     26 27 28 29 30

     *

   Now let's write the buffer contents to a file named 'junk' with the

<w> ("write") command:

     *w junk

     137

     *

   Need we say? It's good practice to frequently write the buffer

contents, since unwritten changes to the buffer will be lost when we

exit 'ed'.

   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. Commands beginning with '#' are

taken as comments and ignored. Input mode lines that begin with '#' are

just more input.

     $ 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

     $

   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

     $

   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 address has been

     # set to the address of 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 address is initially set to the

address of the last line of that file. Similarly, the move command 'm'

sets the current address to the address of the last line moved.

   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.

?

File: ed.info,  Node: Invoking ed,  Next: Line addressing,  Prev: Introduction to line editing,  Up: Top

3 Invoking ed

*************

The format for running 'ed' is:

     ed [OPTIONS] [FILE]

     red [OPTIONS] [FILE]

   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.

   'ed' supports the following options:

'-h'

'--help'

     Print an informative help message describing the options and exit.

'-V'

'--version'

     Print the version number of 'ed' on the standard output and exit.

'-G'

'--traditional'

     Forces backwards compatibility. This affects the behavior of the

     '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.

'-l'

'--loose-exit-status'

     Don't exit with bad status if a command happens to "fail" (for

     example if a substitution command finds nothing to replace). This

     can be useful when 'ed' is invoked as the editor for crontab.

'-p STRING'

'--prompt=STRING'

     Specifies a command prompt. This may be toggled on and off with the

     'P' command.

'-r'

'--restricted'

     Run in restricted mode. This mode disables editing of files out of

     the current directory and execution of shell commands.

'-s'

'--quiet'

'--silent'

     Suppresses diagnostics, the printing of byte counts by 'e', 'E',

     'r' and 'w' commands, and the '!' prompt after a '!' command. This

     option may be useful if 'ed''s standard input is from a script.

'-v'

'--verbose'

     Verbose mode; prints error explanations. This may be toggled on

     and off with the 'H' command.

   Exit status: 0 if no errors occurred; otherwise >0.

?

File: ed.info,  Node: Line addressing,  Next: Regular expressions,  Prev: Invoking ed,  Up: Top

4 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 address of the last line of the

file. In general, the current address is set to the address of the last

line affected by a command.

   One exception to the rule that addresses represent line numbers is

the address '0' (zero). This means "before the first line", and is

valid wherever it makes sense.

   An address range is two addresses separated either by a comma (',')

or a semicolon (';'). In a semicolon-delimited range, the current

address ('.') is set to the first address before the second address is

calculated. This feature can be used to set the starting line for

searches. The value of the first address in a range cannot exceed the

value of the second.

   Addresses can be omitted on either side of the comma or semicolon

separator. If only the first address is given in a range, then the

second address is set to the given address. If only the second address

is given, the resulting address pairs are '1,addr' and '.;addr'

respectively. If a 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. It is an error to give any number of addresses to a command that

requires zero addresses.

   A line address is constructed as follows:

'.'

     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,$'.

'+N'

     The Nth next line, where N is a non-negative number.

'-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.

'-'

     The previous line. This is equivalent to '-1' and may be repeated

     with cumulative effect.

','

     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. A null RE '//' repeats the last search.

'?RE?'

     The previous line containing the regular expression RE. The search

     wraps to the end of the buffer and continues up to the current

     line, if necessary. A null RE '??' repeats the last search.

''x'

     The apostrophe-x character pair addresses the line previously

     marked by a 'k' (mark) command, where 'x' is a lower case letter

     from the portable character set.

   Addresses can be followed by one or more address offsets, optionally

separated by whitespace. Offsets are constructed as follows:

   * '+' or '-' followed by a number adds or subtracts the indicated

     number of lines to or from the address.

   * '+' or '-' not followed by a number adds or subtracts 1 to or from

     the address.

   * A number adds the indicated number of lines to the address.

   It is not an error if an intermediate address value is negative or

greater than the address of the last line in the buffer. It is an error

if the final address value is negative or greater than the address of

the last line in the buffer. It is an error if a search for a RE fails

to find a matching line.

?

File: ed.info,  Node: Regular expressions,  Next: Commands,  Prev: Line addressing,  Up: Top

5 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 text.

   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'

     Any character C not listed below, including '{', '}', '(', ')',

     '<' and '>', matches itself.

'\C'

     Any backslash-escaped character C, other than '{', '}', '(', ')',

     '<', '>', 'b', 'B', 'w', 'W', '+' 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 characters. 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:]

     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)'. 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 expression, then it

     anchors the regular expression to the beginning of a line.

     Otherwise, it matches itself.

'$'

     If '$' is the last character of a regular expression, it anchors

     the regular expression to the end of a line. Otherwise, it matches

     itself.

'\(RE\)'

     Defines a (possibly null) 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

     subexpression. For example, the regular expression '\(a.c\)\1'

     matches the string 'abcabc', but not 'abcadc'. 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.

'\{N,M\}'

'\{N,\}'

'\{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. If any of these forms

     occurs first in a regular expression or subexpression, then it is

     interpreted literally (i.e., the regular expression '\{2\}'

     matches the string '{2}', and so on).

'\<'

'\>'

     Anchors the single character regular expression or subexpression

     immediately following it to the beginning (in the case of '\<') or

     ending (in the case of '\>') of a "word", i.e., in ASCII, a

     maximal string of alphanumeric characters, including the

     underscore (_).

   The following extended operators are preceded by a backslash '\' to

distinguish them from traditional 'ed' syntax.

'\`'

'\''

     Unconditionally matches the beginning '\`' or ending '\'' of a

     line.

'\?'

     Optionally matches the single character regular expression or

     subexpression immediately preceding it. For example, the regular

     expression 'a[bd]\?c' matches the strings 'abc', 'adc' and 'ac'.

     If '\?' occurs at the beginning of a regular expressions or

     subexpression, then it matches a literal '?'.

'\+'

     Matches the single character regular expression or subexpression

     immediately preceding it one or more times. So the regular

     expression 'a+' is shorthand for 'aa*'. If '\+' occurs at the

     beginning of a regular expression or subexpression, then it

     matches a literal '+'.

'\b'

     Matches the beginning or ending (null string) of a word. Thus the

     regular expression '\bhello\b' is equivalent to '\<hello\>'.

     However, '\b\b' is a valid regular expression whereas '\<\>' is

     not.

'\B'

     Matches (a null string) inside a word.

'\w'

     Matches any character in a word.

'\W'

     Matches any character not in a word.

?

File: ed.info,  Node: Commands,  Next: Limitations,  Prev: Regular expressions,  Up: Top

6 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. 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. It is not portable to give more than one print suffix, but

'ed' allows any combination of non-repeated print suffixes and combines

their effects.

   An interrupt (typically <Control-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. The address

     '0' (zero) is valid for this command; it places the entered text at

     the beginning of the buffer. Text is entered in input mode. The

     current address is set to the address of the last line entered or,

     if there were none, to the addressed line.

'(.,.)c'

     Changes lines in the buffer. The addressed lines are deleted from

     the buffer, and text is inserted in their place. Text is entered

     in input mode. The current address is set to the address of the

     last line entered or, if there were none, to the new address of

     the line after the last line deleted; if the lines deleted were

     originally at the end of the buffer, the current address is set to

     the address of the new last line; if no lines remain in the

     buffer, the current address is set to zero.

'(.,.)d'

     Deletes the addressed lines from the buffer. The current address

     is set to the new address of the line after the last line deleted;

     if the lines deleted were originally at the end of the buffer, the

     current address is set to the address of the new last line; if no

     lines remain in the buffer, the current address is set to zero.

'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 address of the last line in the buffer.

     If FILE is prefixed with a bang (!), then it is interpreted as a

     shell command whose output is to be read, (*note shell escape

     command:: '!' below). In this case the default filename is

     unchanged.

     A warning is printed if any changes have been made in the buffer

     since the last 'w' command that wrote the entire buffer to a file.

'E FILE'

     Edits FILE unconditionally. This is similar to the 'e' command,

     except that unwritten changes are discarded without warning.

'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'

     Global command. The global command makes two passes over the file.

     On the first pass, all the addressed lines matching a regular

     expression RE are marked. Then, going sequentially from the

     beginning of the file to the end of the file, the given

     COMMAND-LIST is executed for each marked line, with the current

     address set to the address of that line. Any line modified by the

     COMMAND-LIST is unmarked. The final value of the current address

     is the value assigned by the last command in the last COMMAND-LIST

     executed. If there were no matching lines, the current address is

     unchanged.

     The first command of COMMAND-LIST must appear on the same line as

     the 'g' command. All lines of a multi-line COMMAND-LIST except the

     last line must be terminated with a backslash ('\'). Any commands

     are allowed, except for 'g', 'G', 'v', and 'V'. The '.'

     terminating the input mode of commands 'a', 'c', and 'i' can be

     omitted if it would be the last line of COMMAND-LIST. By default,

     a newline alone in COMMAND-LIST is equivalent to a 'p' command. If

     'ed' is invoked with the command-line option '-G', then a newline

     in COMMAND-LIST is equivalent to a '.+1p' command.

'(1,$)G/RE/'

     Interactive global command. 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. The final value of the current address is

     the value assigned by the last command executed. If there were no

     matching lines, the current address is unchanged.

     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'

     Prints an explanation of the last error.

'H'

     Toggles the printing of error explanations. By default,

     explanations are not printed. It is recommended that ed scripts

     begin with this command to aid in debugging.

'(.)i'

     Inserts text in the buffer before the addressed line. The address

     '0' (zero) is valid for this command; it is equivalent to address

     '1'. Text is entered in input mode. The current address is set to

     the address of the last line entered or, if there were none, to the

     addressed line.

'(.,.+1)j'

     Joins the addressed lines, replacing them by a single line

     containing their joined text. If only one address is given, this

     command does nothing. If lines are joined, the current address is

     set to the address of the joined line. Else, the current address

     is unchanged.

'(.)kx'

     Marks a line with a lower case letter 'x'. The line can then be

     addressed as ''x' (i.e., a single quote followed by 'x') in

     subsequent commands. The mark is not cleared until the line is

     deleted or otherwise modified. The current address is unchanged.

'(.,.)l'

     List command. Prints the addressed lines unambiguously. The end of

     each line is marked with a '$', and every '$' character within the

     text is printed with a preceding backslash. Special characters are

     printed as escape sequences. The current address is set to the

     address of the last line printed.

'(.,.)m(.)'

     Moves lines in the buffer. The addressed lines are moved to after

     the right-hand destination address. The destination address '0'

     (zero) is valid for this command; it moves the addressed lines to

     the beginning of the buffer. It is an error if the destination

     address falls within the range of moved lines. The current address

     is set to the new address of the last line moved.

'(.,.)n'

     Number command. Prints the addressed lines, preceding each line by

     its line number and a <tab>. The current address is set to the

     address of the last line printed.

'(.,.)p'

     Prints the addressed lines. The current address is set to the

     address of the last line printed.

'P'

     Toggles the command prompt on and off. Unless a prompt is

     specified with command-line option '-p', the command prompt is by

     default turned off.

'q'

     Quits 'ed'. A warning is printed if any changes have been made in

     the buffer since the last 'w' command that wrote the entire buffer

     to a file.

'Q'

     Quits 'ed' unconditionally. This is similar to the 'q' command,

     except that unwritten changes are discarded without warning.

'($)r FILE'

     Reads FILE and appends it after the addressed line. If FILE is not

     specified, then the default filename is used. If there is no

     default filename prior to the command, then the default filename

     is set to FILE. Otherwise, the default filename is unchanged. The

     address '0' (zero) is valid for this command; it reads the file at

     the beginning of the buffer. The current address is set to the

     address of the last line read or, if there were none, to the

     addressed line.

     If FILE is prefixed with a bang (!), then it is interpreted as a

     shell command whose output is to be read, (*note shell escape

     command:: '!' below). In this case the default filename is

     unchanged.

'(.,.)s/RE/REPLACEMENT/'

     Substitute command. Replaces text in the addressed lines matching a

     regular expression RE with REPLACEMENT. By default, only the first

     match in each line is replaced. The 's' command accepts any

     combination of the suffixes 'g', 'COUNT', 'l', 'n', and 'p'. If

     the 'g' (global) suffix is given, then every match is replaced.

     The 'COUNT' suffix, where COUNT is a positive number, causes only

     the COUNTth match to be replaced. 'g' and 'COUNT' can't be

     specified in the same command. 'l', 'n', and 'p' are the usual

     print suffixes. It is an error if no substitutions are performed

     on any of the addressed lines. The current address is set to the

     address of the last line on which a substitution occurred. If a

     line is split, a substitution is considered to have occurred on

     each of the new lines. If no substitution is performed, the

     current address is unchanged.

     RE and REPLACEMENT may be delimited by any character other than

     <space>, <newline> and the characters used by the form of the 's'

     command shown below. If the last delimiter is omitted, then the

     last line affected is printed as if the print suffix 'p' were

     specified. The last delimiter can't be omitted if the 's' command

     is part of a 'g' or 'v' COMMAND-LIST and is not the last command

     in the list, because the meaning of the following escaped newline

     becomes ambiguous.

     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 the corresponding backreference expression

     does not match, then the character sequence '\M' is replaced by

     the empty string. If REPLACEMENT consists of a single '%', then

     REPLACEMENT from the last substitution is used.

     A line can be split by including a newline escaped with a backslash

     ('\') in REPLACEMENT, except if the 's' command is part of a 'g'

     or 'v' COMMAND-LIST, because in this case the meaning of the

     escaped newline becomes ambiguous. Each backslash in REPLACEMENT

     removes the special meaning (if any) of the following character.

'(.,.)s'

     Repeats the last substitution. This form of the 's' command accepts

     the 'g' and 'COUNT' suffixes described above, and any combination

     of the suffixes 'p' and 'r'. The 'g' suffix toggles the global

     suffix of the last substitution and resets COUNT to 1. The 'p'

     suffix toggles the print suffixes of the last substitution. The

     'r' suffix causes the regular expression of the last search to be

     used instead of that of the last substitution (if the search

     happened after the substitution).

'(.,.)t(.)'

     Copies (i.e., transfers) the addressed lines to after the

     right-hand destination address. If the destination address is '0'

     (zero), the lines are copied at the beginning of the buffer. The

     current address is set to the address of the last line copied.

'u'

     Undoes the effect of the last command that modified anything in the

     buffer and restores the current address to what it was before the

     command. The global commands 'g', 'G', 'v', and 'V' are treated as

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

'(1,$)v/RE/COMMAND-LIST'

     This is similar to the 'g' command except that it applies

     COMMAND-LIST to each of the addressed lines not matching the

     regular expression RE.

'(1,$)V/RE/'

     This is similar to the 'G' command except that it interactively

     edits the addressed lines not matching the regular expression RE.

'(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.

     If FILE is prefixed with a bang (!), then it is interpreted as a

     shell command and the addressed lines are written to its standard