red man page on DigitalUNIX

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
DigitalUNIX logo
[printable version]

ed(1)									 ed(1)

NAME
       ed, e, red - Edits a file line by line

SYNOPSIS
       ed [-p string] [-s] [-x] [-] [file]

       e [-p string] [-s] [-x] [-] [file]

       red [-p string] [-s] [-x] [-] [file]

       The  ed	command	 is a line editing program that works on one file at a
       time by copying it into a temporary edit buffer and making  changes  to
       that copy.

STANDARDS
       Interfaces  documented on this reference page conform to industry stan‐
       dards as follows:

       ed:  XCU5.0

       e:  XCU5.0

       red:  XCU5.0

       Refer to the standards(5) reference page	 for  more  information	 about
       industry standards and associated tags.

OPTIONS
       Sets  the  ed  prompt  to  string.   The default for string is null (no
       prompt).	 Suppresses byte counts that the editor displays with  the  e,
       E,  r,  and w subcommands, suppresses diagnostic messages for the e, E,
       and q subcommands, and suppresses the  !	  (exclamation	point)	prompt
       after  a !system_command.  This also holds true if you invoke ed with a
       file name.  Suppresses byte counts that the editor displays with the e,
       E,  r,  and w subcommands, suppresses diagnostic messages for the e, E,
       and q subcommands, and suppresses the  !	  (exclamation	point)	prompt
       after  a !system_command.  This also holds true if you invoke ed with a
       file name.  This form is obsolescent and may  be	 withdrawn  in	future
       releases.

	      If  you  quit  without writing the file, you do not get an error
	      message.	(Generally, before ending the  program,	 q  checks  to
	      determine	 whether  the  buffer  was written to a file since the
	      last time it was changed.	 If not, q displays the	 ?   message.)
	      [Tru64  UNIX]  Prompts  for an encryption key and unencrypts the
	      file.  If the file specified is not encrypted  or	 an  incorrect
	      key is entered, garbled text is displayed.

OPERANDS
       The  name  of  the file to be edited.  If this operand is specified, ed
       reads file into the internal buffer before reading standard input.

DESCRIPTION
       The ed command does not alter the file itself until you use  the	 write
       subcommand.   You  can specify on the command line the file you want to
       edit, or you can use ed subcommands to read a  file  into  the  buffer.
       When  ed	 reads	a  new file into the buffer, the contents of that file
       replace the buffer's previous contents, if any.

       [Tru64 UNIX]  There is also a restricted version of ed,	the  red  com‐
       mand,  for use with the restricted shell (rsh).	With red, you can edit
       only files that reside in the current directory, or in the /tmp	direc‐
       tory,  and  you	cannot use the !system_command subcommand (see Subcom‐
       mands section).

       [Tru64 UNIX]  A file may be encrypted  using  the  X  subcommand.  Care
       should  be  take	 to remember the encryption key used as there is not a
       simple way to unencrypt a file if the key used is lost.	Only the first
       six characters of the key are significant.

   Modes for ed
       The  ed	program	 operates  in  one of two modes, command mode and text
       mode.  In command mode, ed recognizes  and  executes  subcommands.   In
       text mode, ed adds text to the file buffer, but does not recognize sub‐
       commands.  You enter text mode by using the a subcommand, c subcommand,
       or  i  subcommand.  To leave text mode, enter (dot) alone at the begin‐
       ning of a line.

       [Tru64 UNIX]  The e command is a supported alias for the ed command.

   Syntax for Subcommands
       An ed subcommand consists of zero, one, or two addresses, followed by a
       single-character	 subcommand,  possibly	followed  by arguments to that
       subcommand.  These addresses specify one or more lines in  the  buffer.
       Because	every  subcommand has default addresses, you frequently do not
       need to specify addresses.

   Pattern Matching
       The ed command supports a  limited  form	 of  special  pattern-matching
       characters  that	 you can use as regular expressions (REs) to construct
       pattern strings.	 You can use these patterns in	addresses  to  specify
       lines and in some subcommands to specify portions of a line.

       [Tru64  UNIX]  For information about regular expressions (REs), see the
       grep command.

   Addressing
       There  are  three  types	 of  ed	 addresses:   line  number  addresses,
       addresses relative to the current line, and pattern addresses.

       The  current line is the point of reference in the buffer and is repre‐
       sented by a (dot).  When you start the ed program, the current line  is
       the  last  line	in  the	 buffer.  As you edit a file, the current line
       changes to the last line affected by a subcommand.  The current line is
       the default address for several ed commands.  (See the Subcommands sec‐
       tion to find out how each subcommand affects the current line.)

       Subcommands for determining and changing the current line are described
       in  the	Subcommands  section.	The  following are guidelines for con‐
       structing addresses: A (dot) addresses the current line.	 A  $  (dollar
       sign)  addresses	 the  last line of the buffer.	The number n addresses
       the nth line of the buffer.  The construct 'x addresses the line marked
       with  a	lowercase  letter, x, by the k subcommand.  The /pattern/ con‐
       struct addresses the next line that contains a  matching	 string.   The
       search  begins  with  the line after the current line and stops when it
       finds a match for the pattern.  If necessary, the search moves  to  the
       end  of	the  buffer,  wraps around to the beginning of the buffer, and
       continues until it either finds a match or returns to the current line.
       The  ?pattern?	construct  addresses the previous line that contains a
       match for the pattern.  The ?pattern?  construct, like  /pattern/,  can
       search the entire buffer, but it does so in the opposite direction.  An
       address followed by +number or -number specifies	 an  address  plus  or
       minus  the indicated number of lines.  (The + (plus sign) is optional.)
       An address that begins with + or - specifies a  line  relative  to  the
       current	line.	For example, -5 is the equivalent of (five lines above
       the current line).  An address that ends with - or + specifies the line
       immediately  before  (-)	 or  immediately after (+) the addressed line.
       Used alone, the - character addresses the line immediately  before  the
       current line.  The + character addresses the line immediately after the
       current line; however, the + character is optional.  The + and -	 char‐
       acters  have a cumulative effect; for example, the address -- addresses
       the line two lines above	 the  current  line.   For  convenience,  a  ,
       (comma)	stands for the address pair 1,$ (first line through last line)
       and a ; (semicolon) stands for the  pair	 (current  line	 through  last
       line).

       Commands that do not accept addresses regard the presence of an address
       as an error.  Commands that do accept addresses can use either given or
       default	addresses.   When given more addresses than it accepts, a com‐
       mand uses the last (rightmost) ones.

       In most cases, a , (comma) separates addresses (for example 2,8).  A  ;
       (semicolon)  can also separate addresses.  A ; between addresses causes
       ed to set the current line to the first address and then calculate  the
       second  address	(for  example,	to  set the starting line for a search
       based on guidelines 5 and 6).  In a pair of addresses, the  first  must
       be numerically smaller than the second.

   Limits for ed
       The  following  is  a  list  of ed size limitations: [Tru64 UNIX]  2048
       bytes per line.	[Tru64 UNIX]  256 bytes per  global  subcommand	 list.
       [Tru64  UNIX]  128 kilobyte buffer size.	 (The buffer not only contains
       the original file, but also editing information.)

       [Tru64 UNIX]  The maximum number of lines depends on the amount of mem‐
       ory  available  to you.	The maximum file size depends on the amount of
       physical data storage (disk or tape drive) available or on the  maximum
       number of lines permitted in user memory.

   Subcommands
       In  most	 cases,	 only one ed subcommand can be entered on a line.  The
       exceptions to this rule are the n, p, and l subcommands, which  can  be
       added to any subcommand except e, E, f, q, Q, r, w, or !.

       The  e, E, f, r, and w subcommands accept file names as arguments.  The
       ed command stores the last file	name  used  with  a  subcommand	 as  a
       default file name.  The next e, E, f, r, or w given without a file name
       uses the default file name.

       The ed command responds to an error condition with one of two messages:
       ?   (question  mark) or ?file. When the ed command receives an INT sig‐
       nal, it displays a ?  and returns to command mode.   When  ed  reads  a
       file,  it  discards  NULL  characters and all characters after the last
       newline character.

       Unless otherwise noted, all subcommands work by default on the  current
       line;  an  address  is optional.	 If you specify an address, you do not
       type the brackets.

       When used as an address, a (dot) refers to the current  line.   When  a
       (dot)  is  shown	 in  the first position on an otherwise blank line, it
       terminates text mode and returns to command mode.  The  text  parameter
       denotes	user input in text mode.  Note that address need not be a num‐
       ber; it can be a regular expression of the form /RE/,/RE/ or /RE/;/RE/.
       The  a  (append) subcommand adds text to the buffer after the addressed
       line.  Enter a (dot) to return to command mode.	The a subcommand  sets
       the  current  line  to  the  last  inserted  line, or, if no lines were
       inserted, to the addressed line. Address 0 (zero) causes the a  subcom‐
       mand  to	 add text to the beginning of the buffer.  The c (change) sub‐
       command deletes the addressed lines, then replaces them with new input.
       Enter  a	 (dot) to return to command mode.  The c command sets the cur‐
       rent line to the last new line of input, or, if there were none, to the
       first line that was not deleted.	 The d (delete) subcommand removes the
       addressed lines from the buffer.	 The line after the last line  deleted
       becomes	the current line.  If the deleted lines were originally at the
       end of the buffer, the new last line becomes the current line.	The  e
       (edit)  subcommand  first  deletes  any	contents from the buffer, then
       loads another file into the buffer, sets the current line to  the  last
       line  of	 the  buffer,  and displays the number of bytes read in to the
       buffer.	If the buffer was changed since its contents were  last	 saved
       (with the w subcommand), e displays ?  before it clears the buffer.

	      The  e  subcommand  stores  file	as the default file name to be
	      used, if necessary, by subsequent e, E,  r,  or  w  subcommands.
	      (See the f subcommand.)

	      When the !  (exclamation point) character replaces file, e takes
	      the rest of the line as a shell (sh) command and reads the  com‐
	      mand  output.   The  e subcommand does not store the name of the
	      shell command as a default file name.  The E  (Edit)  subcommand
	      works  like  e, with one exception: E does not check for changes
	      made to the buffer since the last w  subcommand.	 The  f	 (file
	      name)  subcommand changes the default file name (the stored name
	      of the last file used) to file, if file is given.	  If  file  is
	      not given, the f subcommand prints the default file name.	 The g
	      (global) subcommand first marks every line that matches the pat‐
	      tern.  Then, for each marked line, this subcommand sets the cur‐
	      rent line to that line and  executes  subcommand_list.  Place  a
	      single  subcommand,  or  the  first subcommand of a list, on the
	      same line with the g subcommand; place subsequent subcommands on
	      separate	lines.	 Except	 for  the last line, end each of these
	      lines with a \ (backslash).

	      The subcommand_list can include the a, i, and c subcommands  and
	      their input.  If the last command in subcommand_list is normally
	      the (dot) that ends input mode, the (dot) is optional.  If there
	      is  no  subcommand_list, ed displays the current line.  The sub‐
	      command_list cannot include the g, G, v, V, or !	subcommands.

	      The g subcommand is similar to the v subcommand, which  executes
	      subcommand_list for every line that does not contain a match for
	      the pattern.  This subcommand defaults to the entire  file,  not
	      to  the  current	line.	The  interactive G (Global) subcommand
	      first marks every line that matches the pattern,	then  displays
	      the  first  marked line, sets the current line to that line, and
	      waits for a subcommand. The G subcommand	accepts	 any  but  the
	      following ed subcommands: a, c, i, g, G, v, V, and !.  After the
	      subcommand finishes, G displays the next marked line, and so on.
	      The G subcommand takes a newline character as a null subcommand.
	      The & subcommand causes G to  execute  the  previous  subcommand
	      again,  if  there is one. Subcommands executed within the G sub‐
	      command can address and change any lines in the buffer.	The  G
	      subcommand  can  be  terminated  by  pressing  the Interrupt key
	      sequence.	 This subcommand defaults to the entire file,  not  to
	      the current line.	 The h (help) subcommand displays a short mes‐
	      sage that explains the reason for the most recent	 ?   notifica‐
	      tion.   The current line number is unchanged.  The H (Help) sub‐
	      command causes ed to enter a mode in which  help	messages  (see
	      the  h  command)	are  displayed for all subsequent ?  notifica‐
	      tions.  The H subcommand toggles this mode, and is initially set
	      to “off”.	 The current line number is unchanged.	The i (insert)
	      subcommand inserts text before the addressed line and  sets  the
	      current  line  to the last inserted line.	 Enter (dot) to return
	      to command mode.	If no lines are inserted, i sets  the  current
	      line  to the addressed line.  This subcommand differs from the a
	      subcommand only in the placement of the input text.   Address  0
	      (zero)  is  not legal for this subcommand.  The j (join) subcom‐
	      mand joins contiguous lines by removing the intervening  newline
	      characters.   If	given  only one address, j does nothing.  (For
	      splitting lines, see the s subcommand.)  Lines that  exceed  the
	      line  length  limit  cannot be joined.  If lines are joined, the
	      current line number is set to the address of  the	 joined	 line;
	      otherwise,  the  current line number is unchanged.  The k (mark)
	      subcommand marks the addressed line with name x, which must be a
	      lowercase	 letter.  The address 'x (single quotation mark before
	      the marking character) then addresses this line.	The k  subcom‐
	      mand  does not change the current line.  Marks attached to lines
	      are deleted with the line.  The l (list) subcommand displays the
	      addressed	 lines.	 The l subcommand wraps long lines and, unlike
	      the p subcommand, represents nonprinting characters  as  3-digit
	      octal  numbers  with  a \ (backslash) preceding each byte in the
	      character.  The following characters, however,  are  written  as
	      escape  sequences:  Backslash  Alert  Backspace Formfeed Newline
	      Carriage return Tab Vertical tab

	      A $ (dollar sign) character is placed at the end of  each	 line,
	      so that a real (literal) $ at the end of a line cannot be misin‐
	      terpreted.

	      An l subcommand can be appended to any ed subcommand except:  e,
	      E, f, q, Q, r, w, or !.  The m (move) subcommand repositions the
	      addressed	 lines.	  The  first  moved  line  follows  the	  line
	      addressed	 by  address3.	Address 0 (zero) for address3 causes m
	      to move the addressed lines to the beginning of the  file.   The
	      line  specified  by  address3  cannot  be one of the lines to be
	      moved.  The m subcommand sets the current line to the last moved
	      line.   The  n (number) subcommand displays the addressed lines,
	      each preceded by its line number and a tab character  (displayed
	      as spaces); the n subcommand leaves the current line at the last
	      line displayed.  An n subcommand can be appended to any ed  sub‐
	      command except e, E, f, q, Q, r, w, or !.	 The p (print) subcom‐
	      mand displays the addressed lines and sets the current line  set
	      to  the  last line displayed.  A p subcommand can be appended to
	      any ed subcommand except: e, E, f, q, Q, r, w, or !.  For	 exam‐
	      ple, the subcommand dp deletes the current line and displays the
	      new current line.	 The P (Prompt) subcommand turns the ed prompt
	      string  *	 or  the  string specified by the -p option on or off.
	      Initially, P is off.  The q (quit) subcommand exits the ed  pro‐
	      gram.   Before ending the program, q checks to determine whether
	      the buffer was written to a file since  the  last	 time  it  was
	      changed.	 If  not,  q  displays the ?  message.	You do not get
	      more than one prompt in a row; a second consecutive q quits  the
	      ed program without displaying a prompt.  The Q (Quit) subcommand
	      exits the ed program without checking for changes to the	buffer
	      since  the  last	w  subcommand (compare with the q subcommand).
	      The r (read) subcommand reads a file into the buffer  after  the
	      addressed	 line;	r does not delete the previous contents of the
	      buffer.  When entered without file, r reads the default file, if
	      any,  into  the buffer (see e and f subcommands).	 The r subcom‐
	      mand does not change the default file name.   Address  0	(zero)
	      causes  r	 to  read  a  file  in at the beginning of the buffer.
	      After it reads a file successfully, r, displays  the  number  of
	      bytes read into the buffer and sets the current line to the last
	      line read.

	      If !  (exclamation point) replaces file in  a  r	subcommand,  r
	      takes  the rest of the line as a shell (sh) command whose output
	      is to be read.  The r subcommand does not	 store	the  names  of
	      shell  commands  as default file names.  The s (substitute) sub‐
	      command searches each addressed line for a string	 that  matches
	      the  pattern  and	 then  replaces	 the string with the specified
	      replacement string. Without a number n or the  global  indicator
	      g,  s  replaces only the first matching string on each addressed
	      line.  With n, s replaces the nth occurrence of pattern  on  the
	      addressed	 line.	 With the g indicator, s replaces every occur‐
	      rence of the matching string on each addressed line.

	      If s does not find a match for the pattern, it returns the error
	      message  ?.  Any character except a space or a newline character
	      can separate (delimit) the pattern and replacement.  The s  sub‐
	      command sets the current line to the last line changed.

	      An  &  (ampersand) in the replacement string is a special symbol
	      that has the same value as the pattern string.  So, for example,
	      the subcommand s/out/&ing/ has the same effect as the subcommand
	      s/out/outing/ and replaces out with outing on the current	 line.
	      A backslash before the ampersand (\&) removes this special mean‐
	      ing of & in replacement.

	      The % (percent sign), when used by itself as replacement, causes
	      s	 to  use the previous replacement again.  The % character does
	      not have this special meaning if it is part of a longer replace‐
	      ment or if it is preceded by a \ (backslash).

	      Lines can be split by substituting newline characters into them.
	      In replacement, the sequence \<Return> quotes the newline	 char‐
	      acter  (not  displayed) and moves the cursor to the nextline for
	      the remainder of the string.

	      The value of flags can be the  following:	 Substitutes  for  the
	      countth  occurrence only of the regular expression that is found
	      on each addressed line.  Substitutes globally for	 all  nonover‐
	      lapping  instances  of  the  regular expression, instead of just
	      substituting for the first instance.  Displays the final line in
	      which  a substitution was made in the format specified for the l
	      subcommand.  Displays the final line in which a substitution was
	      made in the format specified for the n subcommand.  Displays the
	      final line in which a substitution was made in the format speci‐
	      fied  for the p subcommand.  The t (transfer) subcommand inserts
	      a copy of the addressed lines after address3.  The t  subcommand
	      accepts  address	0 (for inserting lines at the beginning of the
	      buffer). The t subcommand sets the current line to the last line
	      copied.	The  u	(undo)	subcommand  restores the buffer to the
	      state it was in before it was last modified by an ed subcommand.
	      The  commands  that u can undo are a, c, d, g, G, i, j, m, r, s,
	      t, u, v, and V.  All changes made to the buffer by a g, G, v, or
	      V	 global	 command  are  undone as a single change.  The current
	      line number is set to the value it had before the command	 being
	      undone  started.	 The  v subcommand executes the subcommands in
	      subcommand_list for each line that does not contain a match  for
	      the  pattern.   The  v subcommand is a complement for the global
	      subcommand g, which executes subcommand_list for every line that
	      does  contain  a	match for the pattern.	The V subcommand first
	      marks every line that does not match the pattern, then  displays
	      the  first  marked line, sets the current line to that line, and
	      waits for a subcommand.  The V subcommand complements the G sub‐
	      command, which marks the lines that do match the pattern.	 The w
	      (write) subcommand copies the addressed lines from the buffer to
	      the  file named in file.	If the file does not exist, the w sub‐
	      command creates it with permission mode 666 (read and write per‐
	      mission  for  everyone),	unless	the  umask  setting  specifies
	      another file creation mode.  (For information about file permis‐
	      sions, see umask in sh and chmod.)

	      The  w  subcommand does not change the default file name (unless
	      file is the first file name used since you started ed).  If  you
	      do  not  provide	a file name, ed uses the default file name, if
	      any (see the e, E, and f subcommands).  The  w  subcommand  does
	      not change the current line.

	      If  ed  successfully  writes the file, it displays the number of
	      characters written.  When !  (exclamation point) replaces	 file,
	      ed takes the rest of the line as a shell (sh) command whose out‐
	      put is to be read; w  does  not  save  shell  command  names  as
	      default  file  names  (same  effect as !).  The use of the write
	      subcommand with !	 (exclamation point)  is  not  considered  the
	      last  w  command	that wrote the entire buffer. Thus, this alone
	      does not prevent the warning to the user if an attempt  is  made
	      to destroy the editor buffer through the e or q subcommands.

	      The  address  0  is  not	a  legal address for the w subcommand.
	      Therefore, it is not possible to create an empty file  with  ed.
	      The  X  subcommand prompts you to enter an encryption key.  Only
	      the first six characters of this key are significant.  When  the
	      ed  commands write a file after the encryption key is specified,
	      the output is written in encrypted form. Subsequent edits of the
	      file  require  the  use the -x option to display the file in its
	      unencrypted form.	 Without an address, the = (equal  sign)  sub‐
	      command displays the current line number.	 With the address $, =
	      (equal sign) displays the number of the last line in the buffer.
	      The  = subcommand does not change the current line and cannot be
	      included in a g or  v  subcommand	 list.	 The  !	  (exclamation
	      point)  subcommand  allows system commands to be run from within
	      ed.  Anything following !	 on an ed subcommand  line  is	inter‐
	      preted  as  a  system  command.  Within the text of that command
	      string, ed replaces the unescaped character % with  the  current
	      file name, if there is one.

	      By  default,  the	 subcommands  are executed by /usr/bin/sh.  To
	      support single user mode operation, subcommands can be  executed
	      by  /sbin/sh. To change the default behavior, modify your $SHELL
	      environmental variable to SHELL=/sbin/sh.

	      When used as the first character of a shell command (after the !
	      that  runs  a  subshell),	 ed replaces the !  character with the
	      previous system command; for example, the	 command  !!   repeats
	      the previous system command.  If the command interpreter (the sh
	      command) expands the command  string,  ed	 echoes	 the  expanded
	      line.   The  !  subcommand does not change the current line.  If
	      any replacements of % and/or !  are performed, the modified line
	      is  written  to  standard output before the command is executed.
	      The ed editor interprets a number alone on a line as an  address
	      and  displays  the  addressed  line.   Addresses can be absolute
	      (line numbers or $) or relative to the current line (+number  or
	      -number).	 Entering a newline character (a blank line) is equiv‐
	      alent to +1p and is useful for stepping forward through the buf‐
	      fer one line at a time.

EXIT STATUS
       The  following  exit  values  are  returned: Successful completion.  An
       error occurred.

ASYNCHRONOUS EVENTS
       The following actions are taken upon receipt of signals: The ed command
       interrupts its current activity, writes the string ?\n to standard out‐
       put, and returns to command mode.  If the buffer is not empty  and  has
       changed	since  the last write, the ed command attempts to write a copy
       of the buffer in a file.	 First, the file named ed.hup in  the  current
       directory  is  used; if that fails, the file named ed.hup in the direc‐
       tory named by the HOME environment variable is used. In any  case,  the
       ed command exits without returning to command mode.

ENVIRONMENT VARIABLES
       The  following  environment  variables affect the execution of ed: Pro‐
       vides a default value for the internationalization variables  that  are
       unset  or  null. If LANG is unset or null, the corresponding value from
       the default locale is used.  If any of the  internationalization	 vari‐
       ables contain an invalid setting, the utility behaves as if none of the
       variables had been defined.  If set to a non-empty string value,	 over‐
       rides  the  values  of  all  the	 other internationalization variables.
       Determines the locale for the interpretation of sequences of  bytes  of
       text  data as characters (for example, single-byte as opposed to multi‐
       byte characters in arguments) and the  behavior	of  character  classes
       within  regular	expressions.  Determines the locale for the format and
       contents of diagnostic messages written to standard error.   Determines
       the location of message catalogues for the processing of LC_MESSAGES.

FILES
       Recovery file written if SIGHUP is received during operation.

SEE ALSO
       Commands:  chmod(1),  edit(1),  ex(1),  grep(1), rsh(1), sed(1), Bourne
       shell sh(1b), POSIX shell sh(1p), stty(1), vi(1)

       Functions:  regexp(3)

       Files:  locale(4)

       Standards:  standards(5)

       Command and Shell User's Guide

									 ed(1)
[top]

List of man pages available for DigitalUNIX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net