ed(1) - phpMan

Command: man perldoc info search(apropos)  


ED(1)                                                                    ED(1)



NAME
       ed, red - text editor

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

       red [-GVhs] [-p string] [file]

DESCRIPTION
       ed  is a line-oriented text editor.  It is used to create, display, modify and oth-
       erwise 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 quit-
       ting 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 occurrences 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 sin-
       gle 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.


   OPTIONS
       -G      Forces  backwards  compatibility.  Affects the commands 'G', 'V', 'f', 'l',
               'm', 't', and '!!'.

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


       -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,  prefix  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 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  corre-
       sponding 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 cur-
       rent address, and the second address is interpreted relative 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,$].


       -       The previous line.  This is equivalent to -1 and may be repeated with cumu-
               lative effect.


       ^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 cumula-
               tive effect.


       whitespace n

       +n      The nth next line, where n is a non-negative number.   Whitespace  followed
               by a number n is interpreted as +n.


       ,       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 nec-
               essary.  // 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  neces-
               sary.  ?? repeats the last search.


       'lc     The  line  previously  marked  by a 'k' (mark) command, where lc is a lower
               case letter.


   REGULAR EXPRESSIONS
       Regular expressions are patterns used in selecting text.  For example, the ed  com-
       mand

              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 corre-
       sponding 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      A 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 speci-
               fied  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.] or,   [=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 con-
               structs.

       [^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 regu-
               lar 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 delim-
               iter.

       *       Matches  the  single  character regular expression or subexpression immedi-
               ately preceding it zero or more times.  If '*' is the first character of  a
               regular expression or subexpression, then it matches itself.  The '*' oper-
               ator sometimes yields unexpected results.  For example, the regular expres-
               sion  '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  immedi-
               ately  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 expres-
               sion 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 immedi-
               ately following it to the beginning (\<) or ending (\>) of a word, i.e., in
               ASCII,  a  maximal  string of alphanumeric characters, including the under-
               score (_).


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

   COMMANDS
       All  ed  commands are single characters, though some require additional 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    Appends  text  to  the  buffer  after  the addressed line, which may be the
               address 0 (zero).  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 out-
               put  of command is read.  The current 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 current address is set to the  line  currently  matched
               before  command-list  is executed.  At the end of the 'g' command, the cur-
               rent 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  com-
               mand-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 new-
               line 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 recommended 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 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 invoked from a  terminal,  ed
               pauses  at  the  end  of each page until a newline is entered.  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.    If invoked from a terminal, ed pauses at the
               end of each page until a newline is entered.  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 discarded 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
               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 positive number, causes only the nth match  to  be
               replaced.   It  is an error if no substitutions 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 character other than  space  and
               newline  (see the 's' command below).  If one or two of the last delimiters
               is omitted, then the last line affected is printed as though the print suf-
               fix '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  sub-
               stitution  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  regular  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 desti-
               nation 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
               treated as a single command by undo.  'u' is its own inverse.

       (1,$)v/re/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 matching 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  file-
               name  is  set to file, otherwise it is unchanged.  If no filename is speci-
               fied, then the default filename is used.  The current address is unchanged.

       (1,$)wq file
               Writes the addressed lines to file, and then executes 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    Copies (puts) the contents of the cut buffer to after the  addressed  line.
               The current address is set to the last line copied.

       (.,.)y  Copies  (yanks)  the  addressed lines to the cut buffer.  The cut buffer is
               overwritten by subsequent 'y', 's', 'j', 'd', or 'c' commands.  The current
               address is unchanged.

       (.+1)zn Scrolls  n  lines at a time starting at addressed line.  If n is not speci-
               fied, 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 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.

       (.,.)#  Begins a comment;  the rest of the line, up to a newline, is ignored.  If a
               line address followed by a semicolon is given, then the current address  is
               set to that address.  Otherwise, the current address 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
       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), sh(1).

       USD:12-13

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

LIMITATIONS
       ed  processes file arguments for backslash escapes, i.e.,  in a filename, any char-
       acters 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, 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.

       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.



                                5 October 2006                           ED(1)

Generated by $Id: phpMan.php,v 4.55 2007/09/05 04:42:51 chedong Exp $ Author: Che Dong
On Apache
Under GNU General Public License
2017-12-13 03:27 @127.0.0.1 CrawledBy CCBot/2.0 (http://commoncrawl.org/faq/)
Valid XHTML 1.0!Valid CSS!