diff --git a/notes/edtut.txt b/notes/edtut.txt
new file mode 100644
index 0000000..26d8192
--- /dev/null
+++ b/notes/edtut.txt
@@ -0,0 +1,1188 @@
+
+
+
+
+
+
+
+
+
+      AA TTuuttoorriiaall IInnttrroodduuccttiioonn ttoo tthhee UUNNIIXX TTeexxtt EEddiittoorr
+
+
+
+                      _B_. _W_. _K_e_r_n_i_g_h_a_n
+
+           Bell Laboratories, Murray Hill, N. J.
+
+
+IInnttrroodduuccttiioonn
+
+     _E_d  is  a ``text editor'', that is, an interactive pro-
+gram for creating and modifying ``text'',  using  directions
+provided by a user at a terminal.  The text is often a docu-
+ment like this one, or a program or perhaps data for a  pro-
+gram.
+
+     This  introduction  is  meant  to simplify learning _e_d_.
+The recommended way to learn _e_d is to  read  this  document,
+simultaneously using _e_d to follow the examples, then to read
+the description in section I of the  UNIX  manual,  all  the
+while  experimenting  with _e_d_.  (Solicitation of advice from
+experienced users is also useful.)
+
+     Do the exercises!  They cover material  not  completely
+discussed  in  the  actual text.  An appendix summarizes the
+commands.
+
+DDiissccllaaiimmeerr
+
+     This is an introduction and a tutorial.  For this  rea-
+son,  no  attempt  is  made to cover more than a part of the
+facilities that _e_d offers (although this  fraction  includes
+the  most useful and frequently used parts).  Also, there is
+not enough space to explain basic UNIX procedures.  We  will
+assume  that  you  know  how to log on to UNIX, and that you
+have at least a vague understanding of what a file is.
+
+     You must also know what character to type as  the  end-
+of-line  on your particular terminal.  This is a ``newline''
+on Model  37  Teletypes,  and  ``return''  on  most  others.
+Throughout, we will refer to this character, whatever it is,
+as ``newline''.
+
+GGeettttiinngg SSttaarrtteedd
+
+     We'll assume that you have logged in to UNIX and it has
+just said ``%''.  The easiest way to get _e_d is to type
+   ed   (followed by a newline)
+You  are  now ready to go - _e_d is waiting for you to tell it
+what to do.
+
+
+
+
+
+
+
+
+
+                             -2-
+
+
+CCrreeaattiinngg TTeexxtt -- tthhee AAppppeenndd ccoommmmaanndd ````aa''''
+
+     As our first problem, suppose we want  to  create  some
+text  starting from scratch.  Perhaps we are typing the very
+first draft of a paper; clearly it will have to start  some-
+where,  and  undergo modifications later.  This section will
+show how to get some text in, just to  get  started.   Later
+we'll talk about how to change it.
+
+     When  _e_d  is  first  started, it is rather like working
+with a blank piece of paper - there is no text  or  informa-
+tion present.  This must be supplied by the person using _e_d_;
+it is usually done by typing in the text, or by  reading  it
+into  _e_d from a file.  We will start by typing in some text,
+and return shortly to how to read files.
+
+     First a bit of terminology.  In  _e_d  jargon,  the  text
+being  worked  on is said to be ``kept in a buffer.''  Think
+of the buffer as a work space, if you like, or simply as the
+information that you are going to be editing.  In effect the
+buffer is like the piece of paper, on which  we  will  write
+things, then change some of them, and finally file the whole
+thing away for another day.
+
+     The user tells _e_d what to do  to  his  text  by  typing
+instructions  called ``commands.''  Most commands consist of
+a single letter, which must be typed in  lower  case.   Each
+command is typed on a separate line.  (Sometimes the command
+is preceded by information about what line or lines of  text
+are  to  be  affected  - we will discuss these shortly.)  _E_d
+makes no response to most commands - there is  no  prompting
+or typing of messages like ``ready''.  (This silence is pre-
+ferred by experienced users,  but  sometimes  a  hangup  for
+beginners.)
+
+     The first command is _a_p_p_e_n_d_, written as the letter
+   a
+all by itself.  It means ``append (or add) text lines to the
+buffer, as I type them in.''  Appending is rather like writ-
+ing fresh material on a piece of paper.
+
+     So to enter lines of text into the buffer, we just type
+an ``a'' followed by a newline, followed  by  the  lines  of
+text we want, like this:
+   a
+   Now is the time
+   for all good men
+   to come to the aid of their party.
+   ..
+
+     The  only  way to stop appending is to type a line that
+contains only a period.  The ``..'' is used to tell  _e_d  that
+we  have finished appending.  (Even experienced users forget
+that terminating  ``..''   sometimes.   If  _e_d  seems  to  be
+
+
+
+
+
+
+
+
+
+                             -3-
+
+
+ignoring you, type an extra line with just ``..'' on it.  You
+may then find you've added some garbage lines to your  text,
+which you'll have to take out later.)
+
+     After the append command has been done, the buffer will
+contain the three lines
+   Now is the time
+   for all good men
+   to come to the aid of their party.
+The ``a'' and ``..'' aren't there, because they are not text.
+
+     To  add  more  text to what we already have, just issue
+another ``a'' command, and continue typing.
+
+EErrrroorr MMeessssaaggeess -- ````??''''
+
+     If at any time you make an error in  the  commands  you
+type to _e_d_, it will tell you by typing
+   ?
+This  is  about  as cryptic as it can be, but with practice,
+you can usually figure out how you goofed.
+
+WWrriittiinngg tteexxtt oouutt aass aa ffiillee -- tthhee WWrriittee ccoommmmaanndd ````ww''''
+
+     It's likely that we'll want to save our text for  later
+use.   To  write out the contents of the buffer onto a file,
+we use the _w_r_i_t_e command
+   w
+followed by the filename we want to  write  on.   This  will
+copy the buffer's contents onto the specified file (destroy-
+ing any previous information on the file).  To save the text
+on a file named ``junk'', for example, type
+   w junk
+Leave  a  space  between  ``w''  and the file name.  _E_d will
+respond by printing the number of characters it  wrote  out.
+In our case, _e_d would respond with
+   68
+(Remember  that  blanks and the newline character at the end
+of each line are included in the character count.)   Writing
+a file just makes a copy of the text - the buffer's contents
+are not disturbed, so we can go on adding lines to it.  This
+is an important point.  _E_d at all times works on a copy of a
+file, not the file itself.  No change in the contents  of  a
+file  takes  place until you give a ``w'' command.  (Writing
+out the text onto a file from time to time as  it  is  being
+created  is  a  good idea, since if the system crashes or if
+you make some horrible mistake, you will lose all  the  text
+in  the  buffer but any text that was written onto a file is
+relatively safe.)
+
+LLeeaavviinngg eedd -- tthhee QQuuiitt ccoommmmaanndd ````qq''''
+
+     To terminate a session with _e_d_, save  the  text  you're
+working  on  by  writing  it  onto  a  file  using the ``w''
+
+
+
+
+
+
+
+
+
+                             -4-
+
+
+command, and then type the command
+   q
+which stands for _q_u_i_t_.  The system will respond with  ``%''.
+At this point your buffer vanishes, with all its text, which
+is why you want to write it out before quitting.
+
+EExxeerrcciissee 11::
+
+     Enter _e_d and create some text using
+   a
+   ...li
+   ..
+Write it out using ``w''.  Then leave _e_d with the ``q'' com-
+mand,  and  print  the  file, to see that everything worked.
+(To print a file, say
+   pr filename
+or
+   cat filename
+in response to ``%''.  Try both.)
+
+RReeaaddiinngg tteexxtt ffrroomm aa ffiillee -- tthhee EEddiitt ccoommmmaanndd ````ee''''
+
+     A common way to get text into the buffer is to read  it
+from a file in the file system.  This is what you do to edit
+text that you saved with the ``w''  command  in  a  previous
+session.  The _e_d_i_t command ``e'' fetches the entire contents
+of a file into the buffer.  So if we  had  saved  the  three
+lines  ``Now is the time'', etc., with a ``w'' command in an
+earlier session, the _e_d command
+   e junk
+would fetch the entire contents of the  file  ``junk''  into
+the buffer, and respond
+   68
+which  is the number of characters in ``junk''.  _I_f _a_n_y_t_h_i_n_g
+_w_a_s _a_l_r_e_a_d_y _i_n _t_h_e _b_u_f_f_e_r_, _i_t _i_s _d_e_l_e_t_e_d _f_i_r_s_t_.
+
+     If we use the ``e'' command to read  a  file  into  the
+buffer,  then we need not use a file name after a subsequent
+``w'' command; _e_d remembers the last file name  used  in  an
+``e''  command,  and  ``w'' will write on this file.  Thus a
+common way to operate is
+   ed
+   e file
+   [editing session]
+   w
+   q
+
+     You can find out at any  time  what  file  name  _e_d  is
+remembering  by typing the _f_i_l_e command ``f''.  In our case,
+if we typed
+   f
+_e_d would reply
+   junk
+
+
+
+
+
+
+
+
+
+
+                             -5-
+
+
+RReeaaddiinngg tteexxtt ffrroomm aa ffiillee -- tthhee RReeaadd ccoommmmaanndd ````rr''''
+
+     Sometimes we want to read a file into the buffer  with-
+out destroying anything that is already there.  This is done
+by the _r_e_a_d command ``r''.  The command
+   r junk
+will read the file ``junk'' into the buffer; it adds  it  to
+the end of whatever is already in the buffer.  So if we do a
+read after an edit:
+   e junk
+   r junk
+the buffer will contain _t_w_o copies of the text (six  lines).
+   Now is the time
+   for all good men
+   to come to the aid of their party.
+   Now is the time
+   for all good men
+   to come to the aid of their party.
+Like  the  ``w'' and ``e'' commands, ``r'' prints the number
+of characters read in, after the reading operation  is  com-
+plete.
+
+     Generally speaking, ``r'' is much less used than ``e''.
+
+EExxeerrcciissee 22::
+
+     Experiment with the ``e'' command  -  try  reading  and
+printing  various  files.  You may get an error ``?'', typi-
+cally because you spelled the file name wrong.   Try  alter-
+nately  reading  and  appending  to see that they work simi-
+larly.  Verify that
+   ed filename
+is exactly equivalent to
+   ed
+   e filename
+What does
+   f filename
+do?
+
+PPrriinnttiinngg tthhee ccoonntteennttss ooff tthhee  bbuuffffeerr  --  tthhee  PPrriinntt  ccoommmmaanndd
+````pp''''
+
+     To  _p_r_i_n_t  or list the contents of the buffer (or parts
+of it) on the terminal, we use the print command
+   p
+The way this is done is as follows.  We  specify  the  lines
+where we want printing to begin and where we want it to end,
+separated by a comma, and  followed  by  the  letter  ``p''.
+Thus  to  print the first two lines of the buffer, for exam-
+ple, (that is, lines 1 through 2) we say
+   1,2p (starting line=1, ending line=2 p)
+_E_d will respond with
+   Now is the time
+   for all good men
+
+
+
+
+
+
+
+
+
+                             -6-
+
+
+     Suppose we want to print _a_l_l the lines in  the  buffer.
+We could use ``1,3p'' as above if we knew there were exactly
+3 lines in the buffer.  But in general, we  don't  know  how
+many  there  are, so what do we use for the ending line num-
+ber?  _E_d provides a shorthand symbol for  ``line  number  of
+last  line in buffer'' - the dollar sign ``$''.  Use it this
+way:
+   1,$p
+This will print _a_l_l the lines in the buffer (line 1 to  last
+line.)   If  you want to stop the printing before it is fin-
+ished, push the DEL or Delete key; _e_d will type
+   ?
+and wait for the next command.
+
+     To print the _l_a_s_t line of the buffer, we could use
+   $,$p
+but _e_d lets us abbreviate this to
+   $p
+We can print any single line by typing the line number  fol-
+lowed by a ``p''.  Thus
+   1p
+produces the response
+   Now is the time
+which is the first line of the buffer.
+
+     In  fact,  _e_d  lets  us abbreviate even further: we can
+print any single line by typing _j_u_s_t the line  number  -  no
+need to type the letter ``p''.  So if we say
+   $
+_e_d will print the last line of the buffer for us.
+
+     We can also use ``$'' in combinations like
+   $-1,$p
+which  prints  the last two lines of the buffer.  This helps
+when we want to see how far we got in typing.
+
+EExxeerrcciissee 33::
+
+     As before, create some text using  the  append  command
+and  experiment  with the ``p'' command.  You will find, for
+example, that you can't print line 0 or a  line  beyond  the
+end  of  the  buffer, and that attempts to print a buffer in
+reverse order by saying
+   3,1p
+don't work.
+
+TThhee ccuurrrreenntt lliinnee -- ````DDoott'''' oorr ````..''''
+
+     Suppose our buffer still  contains  the  six  lines  as
+above, that we have just typed
+   1,3p
+and _e_d has printed the three lines for us.  Try typing just
+   p    (no line numbers).
+This will print
+
+
+
+
+
+
+
+
+
+                             -7-
+
+
+   to come to the aid of their party.
+which  is  the  third line of the buffer.  In fact it is the
+last (most recent) line that we  have  done  anything  with.
+(We  just  printed  it!)   We  can repeat this ``p'' command
+without line numbers, and it will continue to print line  3.
+
+     The  reason  is  that _e_d maintains a record of the last
+line that we did anything to (in this case, line 3, which we
+just  printed) so that it can be used instead of an explicit
+line number.  This most recent line is referred  to  by  the
+shorthand symbol
+   ..    (pronounced ``dot'').
+Dot is a line number in the same way that ``$'' is; it means
+exactly ``the current line'', or loosely, ``the line we most
+recently  did something to.''  We can use it in several ways
+- one possibility is to say
+   ..,$p
+This will print all the lines from (including)  the  current
+line  to the end of the buffer.  In our case these are lines
+3 through 6.
+
+     Some commands change the value of dot, while others  do
+not.   The  print command sets dot to the number of the last
+line printed; by our last command, we  would  have  ``..''  =
+``$'' = 6.
+
+     Dot  is most useful when used in combinations like this
+one:
+   ..+1  (or equivalently, ..+1p)
+This means ``print the next line'' and gives us a handy  way
+to step slowly through a buffer.  We can also say
+   ..-1  (or ..-1p )
+which  means  ``print  the  line  _b_e_f_o_r_e the current line.''
+This enables us to go backwards if we wish.  Another  useful
+one is something like
+   ..-3,..-1p
+which prints the previous three lines.
+
+     Don't forget that all of these change the value of dot.
+You can find out what dot is at any time by typing
+   ..=
+_E_d will respond by printing the value of dot.
+
+     Let's summarize some things about the ``p'' command and
+dot.   Essentially  ``p'' can be preceded by 0, 1, or 2 line
+numbers.  If there is no line number given,  it  prints  the
+``current  line'', the line that dot refers to.  If there is
+one line number given (with or without the letter ``p''), it
+prints  that  line  (and dot is set there); and if there are
+two line numbers, it prints all the lines in that range (and
+sets dot to the last line printed.)  If two line numbers are
+specified the first can't be bigger  than  the  second  (see
+Exercise 2.)
+
+
+
+
+
+
+
+
+
+
+                             -8-
+
+
+     Typing a single newline will cause printing of the next
+line - it's equivalent to ``..+1p''.   Try  it.   Try  typing
+``^'' - it's equivalent to ``..-1p''.
+
+DDeelleettiinngg lliinneess:: tthhee ````dd'''' ccoommmmaanndd
+
+     Suppose  we want to get rid of the three extra lines in
+the buffer.  This is done by the _d_e_l_e_t_e command
+   d
+Except that ``d'' deletes lines instead  of  printing  them,
+its  action  is  similar  to that of ``p''.  The lines to be
+deleted are specified for ``d''  exactly  as  they  are  for
+``p'':
+   _s_t_a_r_t_i_n_g _l_i_n_e_, _e_n_d_i_n_g _l_i_n_e d
+Thus the command
+   4,$d
+deletes  lines 4 through the end.  There are now three lines
+left, as we can check by using
+   1,$p
+And notice that ``$'' now is line 3!  Dot is set to the next
+line  after  the  last  line  deleted,  unless the last line
+deleted is the last line in the buffer.  In that  case,  dot
+is set to ``$''.
+
+EExxeerrcciissee 44::
+
+     Experiment  with ``a'', ``e'', ``r'', ``w'', ``p'', and
+``d'' until you are sure that you know  what  they  do,  and
+until  you  understand  how dot, ``$'', and line numbers are
+used.
+
+     If you are adventurous, try  using  line  numbers  with
+``a'',  ``r'',  and ``w'' as well.  You will find that ``a''
+will append lines _a_f_t_e_r the line  number  that  you  specify
+(rather  than  after  dot); that ``r'' reads a file in _a_f_t_e_r
+the line number you specify (not necessarily at the  end  of
+the buffer); and that ``w'' will write out exactly the lines
+you specify, not necessarily the whole buffer.  These varia-
+tions  are  sometimes  handy.  For instance you can insert a
+file at the beginning of a buffer by saying
+   0r filename
+and you can enter lines at the beginning of  the  buffer  by
+saying
+   0a
+   ...li
+   ..
+Notice that ``..w'' is _v_e_r_y different from
+   ..
+   w
+
+MMooddiiffyyiinngg tteexxtt:: tthhee SSuubbssttiittuuttee ccoommmmaanndd ````ss''''
+
+     We  are  now  ready to try one of the most important of
+all commands - the substitute command
+
+
+
+
+
+
+
+
+
+                             -9-
+
+
+   s
+This is the command that is used to change individual  words
+or  letters  within a line or group of lines.  It is what we
+use, for example, for correcting spelling mistakes and  typ-
+ing errors.
+
+     Suppose that by a typing error, line 1 says
+   Now is th time
+-  the ``e'' has been left off ``the''.  We can use ``s'' to
+fix this up as follows:
+   1s/th/the/
+This says: ``in line 1, substitute for the  characters  `th'
+the  characters  `the'.''   To verify that it works (_e_d will
+not print the result automatically) we say
+   p
+and get
+   Now is the time
+which is what we wanted.  Notice that dot must have been set
+to  the  line  where  the substitution took place, since the
+``p'' command printed that line.  Dot is always set this way
+with the ``s'' command.
+
+     The general way to use the substitute command is
+   _s_t_a_r_t_i_n_g_-_l_i_n_e_, _e_n_d_i_n_g_-_l_i_n_e s/_c_h_a_n_g_e _t_h_i_s/_t_o _t_h_i_s/
+Whatever  string  of characters is between the first pair of
+slashes is replaced by whatever is between the second  pair,
+in  _a_l_l  the  lines  between  starting line and ending line.
+Only the first occurrence on each line is changed,  however.
+If you want to change _e_v_e_r_y occurrence, see Exercise 5.  The
+rules for line numbers are the  same  as  those  for  ``p'',
+except that dot is set to the last line changed.  (But there
+is a trap for the unwary: if no substitution took place, dot
+is _n_o_t changed.  This causes an error ``?'' as a warning.)
+
+     Thus we can say
+   1,$s/speling/spelling/
+and  correct  the first spelling mistake on each line in the
+text.  (This is useful for people who  are  consistent  mis-
+spellers!)
+
+     If no line numbers are given, the ``s'' command assumes
+we mean ``make the substitution on line dot'', so it changes
+things  only  on  the  current line.  This leads to the very
+common sequence
+   s/something/something else/p
+which makes some correction on the current  line,  and  then
+prints  it, to make sure it worked out right.  If it didn't,
+we can try again.  (Notice that we put a  print  command  on
+the same line as the substitute.  With few exceptions, ``p''
+can follow any command; no  other  multi-command  lines  are
+legal.)
+
+     It's also legal to say
+   s/ . . . //
+
+
+
+
+
+
+
+
+
+                            -10-
+
+
+which means ``change the first string of characters to _n_o_t_h_-
+_i_n_g'', i.e., remove them.  This is useful for deleting extra
+words  in  a line or removing extra letters from words.  For
+instance, if we had
+   Nowxx is the time
+we can say
+   s/xx//p
+to get
+   Now is the time
+Notice that ``//''  here  means  ``no  characters'',  not  a
+blank.  There _i_s a difference!  (See below for another mean-
+ing of ``//''.)
+
+EExxeerrcciissee 55::
+
+     Experiment with the substitute command.  See what  hap-
+pens  if you substitute for some word on a line with several
+occurrences of that word.  For example, do this:
+   a
+   the other side of the coin
+   ..
+   s/the/on the/p
+You will get
+   on the other side of the coin
+A substitute command changes only the  first  occurrence  of
+the  first string.  You can change all occurrences by adding
+a ``g'' (for ``global'') to the ``s'' command, like this:
+   s/ . . . / . . . /gp
+Try other characters instead of slashes to delimit  the  two
+sets  of  characters  in the ``s'' command - anything should
+work except blanks or tabs.
+
+     (If you get funny results using any of the characters
+   ^    ..    $    [    *    \
+read the section on ``Special Characters''.)
+
+CCoonntteexxtt sseeaarrcchhiinngg -- ````// .. .. .. //''''
+
+     With the substitute command mastered, we can move on to
+another highly important idea of _e_d - context searching.
+
+     Suppose  we  have  our  original three line text in the
+buffer:
+   Now is the time
+   for all good men
+   to come to the aid of their party.
+Suppose we want to find the line that contains ``their''  so
+we  can  change it to ``the''.  Now with only three lines in
+the buffer, it's pretty easy to keep track of what line  the
+word  ``their''  is on.  But if the buffer contained several
+hundred lines, and we'd been making  changes,  deleting  and
+rearranging lines, and so on, we would no longer really know
+what this line number would be.  Context searching is simply
+a  method of specifying the desired line, regardless of what
+
+
+
+
+
+
+
+
+
+                            -11-
+
+
+its number is, by specifying some context on it.
+
+     The way we say ``search for a line that  contains  this
+particular string of characters'' is to type
+   /_s_t_r_i_n_g _o_f _c_h_a_r_a_c_t_e_r_s _w_e _w_a_n_t _t_o _f_i_n_d/
+For example, the _e_d line
+   /their/
+is  a context search which is sufficient to find the desired
+line - it will locate the next occurrence of the  characters
+between  slashes (``their'').  It also sets dot to that line
+and prints the line for verification:
+   to come to the aid of their party.
+``Next occurrence'' means that _e_d  starts  looking  for  the
+string  at  line ``..+1'', searches to the end of the buffer,
+then continues at line 1 and searches to  line  dot.   (That
+is,  the search ``wraps around'' from ``$'' to 1.)  It scans
+all the lines in  the  buffer  until  it  either  finds  the
+desired line or gets back to dot again.  If the given string
+of characters can't be found in any line, _e_d types the error
+message
+   ?
+Otherwise it prints the line it found.
+
+     We  can  do  both the search for the desired line _a_n_d a
+substitution all at once, like this:
+   /their/s/their/the/p
+which will yield
+   to come to the aid of the party.
+There were three parts to that last command: context  search
+for the desired line, make the substitution, print the line.
+
+     The expression ``/their/'' is a context search  expres-
+sion.   In  their  simplest form, all context search expres-
+sions are like this - a string of characters  surrounded  by
+slashes.   Context  searches  are  interchangeable with line
+numbers, so they can be used by themselves to find and print
+a  desired  line, or as line numbers for some other command,
+like ``s''.  We used them both ways in the examples above.
+
+     Suppose the buffer contains the three familiar lines
+   Now is the time
+   for all good men
+   to come to the aid of their party.
+Then the _e_d line numbers
+   /Now/+1
+   /good/
+   /party/-1
+are all context search expressions, and they  all  refer  to
+the  same  line  (line  2).   To make a change in line 2, we
+could say
+   /Now/+1s/good/bad/
+or
+   /good/s/good/bad/
+or
+
+
+
+
+
+
+
+
+
+                            -12-
+
+
+   /party/-1s/good/bad/
+The choice is dictated only by convenience.  We could  print
+all three lines by, for instance
+   /Now/,/party/p
+or
+   /Now/,/Now/+2p
+or  by any number of similar combinations.  The first one of
+these might be better if we don't know how  many  lines  are
+involved.  (Of course, if there were only three lines in the
+buffer, we'd use
+   1,$p
+but not if there were several hundred.)
+
+     The basic rule is: a context search expression  is  _t_h_e
+_s_a_m_e  _a_s  a  line  number, so it can be used wherever a line
+number is needed.
+
+EExxeerrcciissee 66::
+
+     Experiment with context searching.  Try a body of  text
+with  several  occurrences of the same string of characters,
+and scan through it using the same context search.
+
+     Try using context searches as line numbers for the sub-
+stitute,  print and delete commands.  (They can also be used
+with ``r'', ``w'', and ``a''.)
+
+     Try  context  searching  using  ``?text?''  instead  of
+``/text/''.  This scans lines in the buffer in reverse order
+rather than normal.  This is sometimes useful if you go  too
+far  while  looking  for some string of characters - it's an
+easy way to back up.
+
+     (If you get funny results with any of the characters
+   ^    ..    $    [    *    \
+read the section on ``Special Characters''.)
+
+     _E_d provides a shorthand for repeating a context  search
+for the same string.  For example, the _e_d line number
+   /string/
+will  find the next occurrence of ``string''.  It often hap-
+pens that this is not the desired line, so the  search  must
+be repeated.  This can be done by typing merely
+   //
+This  shorthand  stands for ``the most recently used context
+search expression.''  It can  also  be  used  as  the  first
+string of the substitute command, as in
+   /string1/s//string2/
+which  will  find  the  next  occurrence  of ``string1'' and
+replace it by ``string2''.  This can save a lot  of  typing.
+Similarly
+   ??
+means ``scan backwards for the same expression.''
+
+
+
+
+
+
+
+
+
+
+                            -13-
+
+
+CChhaannggee aanndd IInnsseerrtt -- ````cc'''' aanndd ````ii''''
+
+     This section discusses the _c_h_a_n_g_e command
+   c
+which  is  used  to change or replace a group of one or more
+lines, and the _i_n_s_e_r_t command
+   i
+which is used for inserting a group of one or more lines.
+
+     ``Change'', written as
+   c
+is used to replace a number of lines with  different  lines,
+which  are typed in at the terminal.  For example, to change
+lines ``..+1'' through ``$'' to something else, type
+    .+1,$c
+    . . . _t_y_p_e _t_h_e _l_i_n_e_s _o_f _t_e_x_t _y_o_u _w_a_n_t _h_e_r_e . . .
+    ..
+The lines you type between the ``c'' command and  the  ``..''
+will take the place of the original lines between start line
+and end line.  This is most useful in replacing  a  line  or
+several lines which have errors in them.
+
+     If  only  one  line  is specified in the ``c'' command,
+then just that line is replaced.  (You can type in  as  many
+replacement  lines as you like.)  Notice the use of ``..'' to
+end the input - this works just like the ``..'' in the append
+command and must appear by itself on a new line.  If no line
+number is given, line dot is replaced.  The value of dot  is
+set to the last line you typed in.
+
+     ``Insert'' is similar to append - for instance
+   /string/i
+   ...li
+   ..
+will  insert  the  given text _b_e_f_o_r_e the next line that con-
+tains ``string''.  The  text  between  ``i''  and  ``..''  is
+_i_n_s_e_r_t_e_d  _b_e_f_o_r_e  the  specified line.  If no line number is
+specified dot  is  used.   Dot  is  set  to  the  last  line
+inserted.
+
+EExxeerrcciissee 77::
+
+     ``Change''  is rather like a combination of delete fol-
+lowed by insert.  Experiment to verify that
+   _s_t_a_r_t_, _e_n_d d
+   i
+    _. _. _. _t_e_x_t _. _. _.
+   ..
+is almost the same as
+   _s_t_a_r_t_, _e_n_d c
+    _. _. _. _t_e_x_t _. _. _.
+   ..
+These are not _p_r_e_c_i_s_e_l_y the same if line ``$'' gets deleted.
+Check this out.  What is dot?
+
+
+
+
+
+
+
+
+
+                            -14-
+
+
+     Experiment  with  ``a'' and ``i'', to see that they are
+similar, but not the same.  You will observe that
+   _l_i_n_e_-_n_u_m_b_e_r a
+   ...li
+   ..
+appends _a_f_t_e_r the given line, while
+   _l_i_n_e_-_n_u_m_b_e_r i
+   ...li
+   ..
+inserts _b_e_f_o_r_e it.  Observe that if no line number is given,
+``i''  inserts  before  line  dot, while ``a'' appends after
+line dot.
+
+MMoovviinngg tteexxtt aarroouunndd:: tthhee ````mm'''' ccoommmmaanndd
+
+     The move command ``m'' is used for cutting and  pasting
+-  it  lets  you  move  a  group  of lines from one place to
+another in the buffer.  Suppose we want  to  put  the  first
+three  lines  of the buffer at the end instead.  We could do
+it by saying:
+   1,3w temp
+   $r temp
+   1,3d
+(Do you see why?)  but we can do it a lot  easier  with  the
+``m'' command:
+   1,3m$
+The general case is
+   _s_t_a_r_t _l_i_n_e_, _e_n_d _l_i_n_e m _a_f_t_e_r _t_h_i_s _l_i_n_e
+Notice  that  there  is  a  third line to be specified - the
+place where the moved stuff gets put.  Of course  the  lines
+to be moved can be specified by context searches; if we had
+   First paragraph
+   ..end of first paragraph.
+   Second paragraph
+   ..end of second paragraph.
+we could reverse the two paragraphs like this:
+   /Second/,/second/m/First/-1
+Notice  the ``-1'' - the moved text goes _a_f_t_e_r the line men-
+tioned.  Dot gets set to the last line moved.
+
+TThhee gglloobbaall ccoommmmaannddss ````gg'''' aanndd ````vv''''
+
+     The _g_l_o_b_a_l command ``g'' is used to execute one or more
+_e_d commands on all those lines in the buffer that match some
+specified string.  For example
+   g/peling/p
+prints all lines that contain ``peling''.  More usefully,
+   g/peling/s//pelling/gp
+makes the substitution everywhere on the line,  then  prints
+each corrected line.  Compare this to
+   1,$s/peling/pelling/gp
+which only prints the last line substituted.  Another subtle
+difference is that the ``g'' command does not give  a  ``?''
+if ``peling'' is not found where the ``s'' command will.
+
+
+
+
+
+
+
+
+
+                            -15-
+
+
+     There  may  be several commands (including ``a'', ``c''
+``i'' ``r'', ``w'', but not ``g''); in that case, every line
+except the last must end with a backslash ``\'':
+   g/xxx/..-1s/abc/def/\
+   ..+2s/ghi/jkl/\
+   ..-2,..p
+makes  changes  in the lines before and after each line that
+contains ``xxx'', then prints all three lines.
+
+     The ``v'' command is the same as ``g'', except that the
+commands  are executed on every line that does _n_o_t match the
+string following ``v'':
+   v/ /d
+deletes every line that does not contain a blank.
+
+SSppeecciiaall CChhaarraacctteerrss
+
+     You may have noticed that things just don't work  right
+when  you used some characters like ``.'', ``*'', ``$'', and
+others in context searches and the substitute command.   The
+reason  is  rather  complex,  although  the  cure is simple.
+Basically, _e_d treats these characters as special, with  spe-
+cial  meanings.   For  instance,  _i_n _a _c_o_n_t_e_x_t _s_e_a_r_c_h _o_r _t_h_e
+_f_i_r_s_t _s_t_r_i_n_g _o_f _t_h_e _s_u_b_s_t_i_t_u_t_e _c_o_m_m_a_n_d _o_n_l_y_, ..  means  ``any
+character,'' not a period, so
+   /x..y/
+means  ``a  line  with  an  x, _a_n_y _c_h_a_r_a_c_t_e_r_, and a y,'' _n_o_t
+just ``a line with an x, a period, and a  y.''~  A  complete
+list of the special characters that can cause trouble is the
+following:
+   ^    ..    $    [    *    \
+_W_a_r_n_i_n_g_: The backslash character \ is special  to  _e_d_.   For
+safety's  sake, avoid it where possible.  If you have to use
+one of the special characters in a substitute  command,  you
+can  turn  off its magic meaning temporarily by preceding it
+with the backslash.  Thus
+   s/\\\..\*/backslash dot star/
+will change ``\..*'' into ``backslash dot star''.
+
+     Here is a hurried synopsis of the other special charac-
+ters.  First, the circumflex `` ^ '' signifies the beginning
+of a line.  Thus
+   /^string/
+finds ``string'' only if it is at the beginning of  a  line:
+it will find
+   string
+but not
+   the string...
+The  dollar-sign  ``$''  is just the opposite of the circum-
+flex; it means the end of a line:
+   /string$/
+will only find an occurrence of ``string'' that  is  at  the
+end of some line.  This implies, of course, that
+   /^string$/
+
+
+
+
+
+
+
+
+
+                            -16-
+
+
+will find only a line that contains just ``string'', and
+   /^..$/
+finds a line containing exactly one character.
+
+     The  character  ``..'',  as  we mentioned above, matches
+anything;
+   /x..y/
+matches any of
+   x+y
+   x-y
+   x y
+   x..y
+This is useful in conjunction with ``*'', which is a repeti-
+tion  character;  ``a*''  is a shorthand for ``any number of
+a's,'' so ``..*'' matches any number of anythings.   This  is
+used like this:
+   s/..*/stuff/
+which changes an entire line, or
+   s/..*,//
+which deletes all characters in the line up to and including
+the last comma.  (Since ``..*'' finds  the  longest  possible
+match, this goes up to the last comma.)
+
+     ``['' is used with ``]'' to form ``character classes'';
+for example,
+   /[1234567890]/
+matches any single digit _ any one of the characters  inside
+the braces will cause a match.
+
+     Finally,  the ``&'' is another shorthand character - it
+is used only on the right-hand part of a substitute  command
+where  it  means  ``whatever  was  matched  on the left-hand
+side''.  It is used to save  typing.   Suppose  the  current
+line contained
+   Now is the time
+and  we  wanted to put parentheses around it.  We could just
+retype the line, but this is tedious.  Or we could say
+   s/^/(/
+   s/$/)/
+using our knowledge of ``^'' and ``$''.  But the easiest way
+uses the ``&'':
+   s/..*/(&)/
+This  says  ``match the whole line, and replace it by itself
+surrounded by parens.''~ The ``&'' can be used several times
+in a line; consider using
+   s/..*/&?  &!!/
+to produce
+   Now is the time?  Now is the time!!
+
+     We  don't  have  to match the whole line, of course: if
+the buffer contains
+   the end of the world
+we could type
+   /world/s//& is at hand/
+
+
+
+
+
+
+
+
+
+                            -17-
+
+
+to produce
+   the end of the world is at hand
+Observe this expression carefully, for it illustrates how to
+take advantage of _e_d to save typing.  The string ``/world/''
+found the desired line; the shorthand ``//'' found the  same
+word  in  the  line;  and  the ``&'' saved us from typing it
+again.
+
+     The ``&''  is  a  special  character  only  within  the
+replacement text of a substitute command, and has no special
+meaning elsewhere.  We can turn off the special  meaning  of
+``&'' by preceding it with a ``\'':
+   s/ampersand/\&/
+will  convert the word ``ampersand'' into the literal symbol
+``&'' in the current line.
+
+
+
+SSuummmmaarryy ooff CCoommmmaannddss aanndd LLiinnee NNuummbbeerrss
+
+     The general form of _e_d commands is  the  command  name,
+perhaps  preceded  by  one  or two line numbers, and, in the
+case of _e_, _r and _w_, followed by a file name.  Only one  com-
+mand  is  allowed  per  line, but a _p command may follow any
+other command (except for _e_, _r_, _w and _q_)_.
+
+_a _(_a_p_p_e_n_d_) Add lines to the buffer (at line  dot,  unless  a
+different  line  is  specified).  Appending  continues until
+``..''  is typed on a new line.  Dot is set to the last  line
+appended.
+_c  _(_c_h_a_n_g_e_) Change the specified lines to the new text which
+follows.  The new lines are terminated by a  ``..''.   If  no
+lines  are  specified, replace line dot.  Dot is set to last
+line changed.
+_d _(_d_e_l_e_t_e_) Delete the lines specified.  If none  are  speci-
+fied,  delete  line  dot.  Dot is set to the first undeleted
+line, unless ``$'' is deleted, in which case dot is  set  to
+``$''.
+_e _(_e_d_i_t_) Edit new file.  Any previous contents of the buffer
+are thrown away, so issue a _w beforehand if you want to save
+them.
+_f _(_f_i_l_e_) Print remembered filename.  If a name follows _f the
+remembered name will be set to it.
+_g _(_g_l_o_b_a_l_) _g_/_-_-_-_/_c_o_m_m_a_n_d_s will execute the commands on those
+lines  that contain ``---'', which can be any context search
+expression.
+_i _(_i_n_s_e_r_t_) Insert lines before specified line (or dot) until
+a  ``..''  is  typed  on a new line.  Dot is set to last line
+inserted.
+_m _(_m_o_v_e_) Move lines specified to after the line named  after
+_m_.  Dot is set to the last line moved.
+_p  _(_p_r_i_n_t_)  Print specified lines.  If none specified, print
+line dot.  A single line number is equivalent to ``line-num-
+ber p''.  A single newline prints ``..+1'', the next line.
+
+
+
+
+
+
+
+
+
+                            -18-
+
+
+_q _(_q_u_i_t_) Exit from ed.  Wipes out all text in buffer!!
+_r  _(_r_e_a_d_)  Read  a file into buffer (at end unless specified
+elsewhere.) Dot set to last line read.
+_s _(_s_u_b_s_t_i_t_u_t_e_) _s_/_s_t_r_i_n_g_1_/_s_t_r_i_n_g_2_/ will substitute the  char-
+acters of `string2' for `string1' in specified lines.  If no
+line is specified, make substitution in line  dot.   Dot  is
+set  to  last line in which a substitution took place, which
+means that  if  no  substitution  took  place,  dot  is  not
+changed.   _s changes only the first occurrence of string1 on
+a line; to change all of them, type a ``g'' after the  final
+slash.
+_v  _(_e_x_c_l_u_d_e_)  _v_/_-_-_-_/_c_o_m_m_a_n_d_s  executes ``commands'' on those
+lines that _d_o _n_o_t contain ``---''.
+_w _(_w_r_i_t_e_) Write out buffer onto a file.  Dot is not changed.
+_P_r_i_n_t  _v_a_l_u_e  _o_f  _d_o_t_.  (``='' by itself prints the value of
+``$''.)
+_! _(_t_e_m_p_o_r_a_r_y _e_s_c_a_p_e_)
+   Execute this line as a UNIX command.
+_/_-_-_-_-_-_/ Context search.  Search for next line which contains
+this  string  of  characters.  Print it.  Dot is set to line
+where string found.  Search starts at ``..+1'', wraps  around
+from ``$'' to 1, and continues to dot, if necessary.
+_?_-_-_-_-_-_?   Context search in reverse direction.  Start search
+at ``..-1'', scan to 1, wrap around to ``$''.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
