From 6b0ffc7fb3b305ce9664c044c36a29ebdd3993cc Mon Sep 17 00:00:00 2001 From: "warren.toomey" Date: Sun, 18 May 2008 00:22:06 +0000 Subject: [PATCH] And here is the ed tutorial from 6th Edition UNIX. --- notes/edtut.txt | 1188 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1188 insertions(+) create mode 100644 notes/edtut.txt 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 ``$''. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +