![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jove.1 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 17.jove|
Return to jove.1 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 17.jove |
1.1 ! root 1: .\" @(#)jove.1 6.1 (Berkeley) 5/30/86 ! 2: .\" ! 3: .\" ditroff -ms ! 4: .de IQ ! 5: \\fI\\$1\\fP ! 6: .. ! 7: .de dc ! 8: .NH 2 ! 9: \\$1 ! 10: .if '\\$2'(variable)' (variable) ! 11: .if !'\\$2'(variable)' (\\$2) ! 12: .LP ! 13: .. ! 14: .nr LL 6.5i ! 15: .nr LT 6.5i ! 16: .EH 'USD:17-%''JOVE Manual for UNIX Users' ! 17: .OH 'JOVE Manual for UNIX Users''USD:17-%' ! 18: .LP ! 19: .TL ! 20: JOVE Manual for UNIX Users ! 21: .AU ! 22: Jonathan Payne ! 23: (revised for 4.3BSD by Doug Kingston and Mark Seiden) ! 24: .AI ! 25: .AB no ! 26: .AE ! 27: .NH 1 ! 28: Introduction ! 29: .XS \n(PN ! 30: \*(SN Introduction ! 31: .XE ! 32: .LP ! 33: \s-2JOVE\s0* ! 34: .FS ! 35: *\s-2JOVE\s0 stands for Jonathan's Own Version of Emacs. ! 36: .FE ! 37: is an advanced, self-documenting, customizable real-time display editor. ! 38: It (and this tutorial introduction) are based on the original EMACS editor and user ! 39: manual written at M.I.T. by Richard Stallman+. ! 40: .FS ! 41: +Although \s-2JOVE\s0 is meant to be compatible with EMACS, ! 42: and indeed many of the basic commands are very similar, ! 43: there are some major differences between the two editors, ! 44: and you should not rely on their behaving identically. ! 45: .FE ! 46: .LP ! 47: \s-2JOVE\s0 is considered a ! 48: .I display ! 49: editor because normally the text being ! 50: edited is visible on the screen and is updated automatically as you ! 51: type your commands. ! 52: .LP ! 53: It's considered a ! 54: .I real-time ! 55: editor because the display is updated very ! 56: frequently, usually after each character or pair of characters you type. ! 57: This minimizes the amount of information you must keep in your ! 58: head as you edit. ! 59: .LP ! 60: \s-2JOVE\s0 is ! 61: .I advanced ! 62: because it provides facilities that go beyond ! 63: simple insertion and deletion: ! 64: filling of text; ! 65: automatic indentations of programs; ! 66: view more than one file at once; ! 67: and dealing in terms of characters, words, lines, sentences and paragraphs. ! 68: It is much easier ! 69: to type one command meaning "go to the end of the paragraph" than to ! 70: find the desired spot with repetition of simpler commands. ! 71: .LP ! 72: .I Self-documenting ! 73: means that at almost any time you can easily ! 74: find out what a command does, ! 75: or to find all the commands that pertain to a topic. ! 76: .LP ! 77: .I Customizable ! 78: means that you can change the definition of \s-2JOVE\s0 commands ! 79: in little ways. ! 80: For example, you can rearrange the command set; ! 81: if you prefer to use arrow keys for the four basic cursor motion commands ! 82: (up, down, left and right), you can. ! 83: Another sort of customization is ! 84: writing new commands by combining built in commands. ! 85: .NH 1 ! 86: The Organization of the Screen ! 87: .XS \n(PN ! 88: \*(SN The Organization of the Screen ! 89: .XE ! 90: .LP ! 91: \s-2JOVE\s0 divides the screen up into several sections. ! 92: The biggest of these sections is used to display the text you are editing. ! 93: The terminal's cursor shows the position of \fIpoint\fP, ! 94: the location at which editing takes place. ! 95: While the cursor appears to point \fIat\fP a character, ! 96: point should be thought of as between characters; ! 97: it points \fIbefore\fP the character that the cursor appears on top of. ! 98: Terminals have only one cursor, ! 99: and when output is in progress it must appear where the typing is being done. ! 100: This doesn't mean that point is moving; ! 101: it is only that \s-2JOVE\s0 has no way of ! 102: showing you the location of point except when the terminal is idle. ! 103: .LP ! 104: The lines of the screen are usually available for displaying text but ! 105: sometimes are pre-empted by typeout from certain commands (such as a ! 106: listing of all the editor commands). ! 107: Most of the time, ! 108: output from commands like these is only desired for a short period of time, ! 109: usually just long enough to glance at it. ! 110: When you have finished looking at the output, ! 111: you can type Space to make your text reappear. ! 112: (Usually a Space that you type inserts itself, but when there is typeout on ! 113: the screen, it does nothing but get rid of that). ! 114: Any other command executes normally, ! 115: .I after ! 116: redrawing your text. ! 117: .NH 2 ! 118: The Message Line ! 119: .XS \n(PN 5n ! 120: \*(SN The Message Line ! 121: .XE ! 122: .LP ! 123: The bottom line on the screen, called the ! 124: \fImessage line\fP, ! 125: is reserved for printing messages and for accepting input from the user, ! 126: such as filenames or search strings. ! 127: When ! 128: \s-2JOVE\s0 ! 129: prompts for input, ! 130: the cursor will temporarily appear on the bottom line, waiting for you ! 131: to type a string. ! 132: When you have finished typing your input, you can ! 133: type a Return to send it to \s-2JOVE\s0. ! 134: If you change your mind about running the command that is waiting for input, ! 135: you can type Control-G to abort, ! 136: and you can continue with your editing. ! 137: .LP ! 138: When \s-2JOVE\s0 is prompting for a filename, ! 139: all the usual editing facilities can be used to fix typos and such; ! 140: in addition, \s-2JOVE\s0 has the following extra functions: ! 141: .IP "^N" ! 142: Insert the next filename from the argument list. ! 143: .IP "^P" ! 144: Insert the previous filename from the argument list. ! 145: .IP "^R" ! 146: Insert the full pathname of the file in the current buffer. ! 147: .LP ! 148: Sometimes you will see \fB--more--\fP on the message line. ! 149: This happens when typeout from a command is too long to fit in the screen. ! 150: It means that if you type a Space the next screenful of typeout will be ! 151: printed. ! 152: If you are not interested, ! 153: typing anything but a Space will cause the rest of the output to be discarded. ! 154: Typing C-G will discard the output and print \fIAborted\fP where the \fB--more--\fP was. ! 155: Typing any other command will discard the rest of the output and ! 156: also execute the command. ! 157: .LP ! 158: The message line and the list of filenames from the shell command that ! 159: invoked \s-2JOVE\s0 are kept in a special buffer called ! 160: \fIMinibuf\fP that can be edited like any other buffer. ! 161: .NH 2 ! 162: The Mode Line ! 163: .XS \n(PN 5n ! 164: \*(SN The Mode Line ! 165: .XE ! 166: .LP ! 167: At the bottom of the screen, but above the message line, is the ! 168: \fImode line\fP. The mode line format looks like this: ! 169: .DS I ! 170: \fBJOVE (major minor) Buffer: bufr "file" *\fP ! 171: .DE ! 172: \fImajor\fP is the name of the current \fImajor mode\fP. ! 173: At any time, \s-2JOVE\s0 can be in only one major mode at a time. ! 174: Currently there are only four major modes: \fIFundamental\fP, ! 175: \fIText\fP, \fILisp\fP and \fIC\fP. ! 176: .LP ! 177: \fIminor\fP is a list of the minor modes that are turned on. ! 178: \fBAbbrev\fP means that \fIWord Abbrev\fP mode is on; ! 179: \fBAI\fP means that \fIAuto Indent\fP mode is on; ! 180: \fBFill\fP means that \fIAuto Fill\fP mode is on; ! 181: \fBOvrWt\fP means that \fIOver Write\fP mode is on. ! 182: \fBDef\fP means that you are in the process of defining a keyboard macro. ! 183: This is not really a mode, ! 184: but it's useful to be reminded about it. ! 185: The meanings of these modes are described later in this document. ! 186: .LP ! 187: \fIbufr\fP is the name of the currently selected \fIbuffer\fP. ! 188: Each buffer has its own name and holds a file being edited; ! 189: this is how \s-2JOVE\s0 can hold several files at once. ! 190: But at any given time you are editing only one of them, ! 191: the \fIselected\fP buffer. ! 192: When we speak of what some command does to "the buffer", ! 193: we are talking about the currently selected buffer. ! 194: Multiple buffers makes it easy to switch around between several files, ! 195: and then it is very useful that ! 196: the mode line tells you which one you are editing at any time. (You ! 197: will see later that it is possible to divide the ! 198: screen into multiple \fIwindows\fP, each showing a different buffer. If you ! 199: do this, there is a mode line beneath each window.) ! 200: .LP ! 201: \fIfile\fP is the name of the file that you are editing. ! 202: This is the default filename for commands that expect a filename as input. ! 203: .LP ! 204: The asterisk at the end of the mode line means that there are changes in ! 205: the buffer that have not been saved in the file. ! 206: If the file has not been changed since it was read in or saved, ! 207: there is no asterisk. ! 208: .NH 1 ! 209: Command Input Conventions ! 210: .XS \n(PN ! 211: \*(SN Command Input Conventions ! 212: .XE ! 213: .LP ! 214: .NH 2 ! 215: Notational Conventions for ASCII Characters ! 216: .XS \n(PN 5n ! 217: \*(SN Notational Conventions for ASCII Characters ! 218: .XE ! 219: .LP ! 220: In this manual, ! 221: "Control" characters ! 222: (that is, characters that are typed with the Control key ! 223: and some other key at the same time) ! 224: are represented by "C-" followed by another character. ! 225: Thus, ! 226: C-A is the character you get when you type A with the Control key ! 227: (sometimes labeled CTRL) down. ! 228: Most control characters when present in the \s-2JOVE\s0 ! 229: buffer are displayed with a caret; thus, ^A for C-A. ! 230: Rubout (or DEL) is displayed as ^?, escape as ^[. ! 231: .NH 2 ! 232: Command and Filename Completion ! 233: .XS \n(PN 5n ! 234: \*(SN Command and Filename Completion ! 235: .XE ! 236: .LP ! 237: When you are typing the name of a \s-2JOVE\s0 command, you need type only ! 238: enough letters to make the name unambiguous. At any point in the course of ! 239: typing the name, you can type question mark (?) to see a list of all the ! 240: commands whose names begin with the characters you've already typed; you can ! 241: type Space to have \s-2JOVE\s0 supply as many characters as it can; or you ! 242: can type Return to complete the command if there is only one possibility. ! 243: For example, if you have typed the letters "\fIau\fP" and you then type a ! 244: question mark, you will see the list ! 245: .DS I ! 246: auto-execute-command ! 247: auto-execute-macro ! 248: auto-fill-mode ! 249: auto-indent-mode ! 250: .DE ! 251: If you type a Return at this point, \s-2JOVE\s0 will complain by ringing ! 252: the bell, because the letters you've typed do not unambiguously specify a ! 253: single command. But if you type Space, \s-2JOVE\s0 will supply the ! 254: characters "\fIto-\fP" because all commands that begin "\fIau\fP" also ! 255: begin "\fIauto-\fP". You could then type the letter "\fIf\fP" followed ! 256: by either Space or Return, and \s-2JOVE\s0 would complete the entire ! 257: command. ! 258: .LP ! 259: Whenever \s-2JOVE\s0 is prompting you for a filename, ! 260: say in the \fIfind-file\fP command, ! 261: you also need only type enough of the name to make it unambiguous with ! 262: respect to files that already exist. In this case, question mark and ! 263: Space work just as they do in command completion, but Return always ! 264: accepts the name just as you've typed it, because you might want to ! 265: create a new file with a name similar to that of an existing file. ! 266: .NH 1 ! 267: Commands and Variables ! 268: .XS \n(PN ! 269: \*(SN Commands and Variables ! 270: .XE ! 271: .LP ! 272: \s-2JOVE\s0 is composed of \fIcommands\fP ! 273: which have long names such as ! 274: \fInext-line\fP. ! 275: Then \fIkeys\fP such as C-N are connected to ! 276: commands through the \fIcommand dispatch table\fP. ! 277: When we say that C-N moves the cursor down a line, ! 278: we are glossing over a distinction which is unimportant for ordinary use, ! 279: but essential for simple customization: ! 280: it is the command \fInext-line\fP which knows how to move a down line, ! 281: and C-N moves down a line because it is connected to that command. ! 282: The name for this connection is a \fIbinding\fP; we say that the key ! 283: C-N \fIis bound to\fP the command \fInext-line\fP. ! 284: .LP ! 285: Not all commands are bound to keys. To invoke a command that isn't bound ! 286: to a key, you can type the sequence ESC X, which is bound to the command ! 287: \fIexecute-named-command\fP. You will then be able to type the name of ! 288: whatever command you want to execute on the message line. ! 289: .LP ! 290: Sometimes the description of a command will say ! 291: "to change this, set the variable \fImumble\-foo\fP". ! 292: A variable is a name used to remember a value. ! 293: \s-2JOVE\s0 contains variables which are there so that you can change ! 294: them if you want to customize. ! 295: The variable's value is examined by some command, ! 296: and changing that value makes the command behave differently. ! 297: Until you are interesting in customizing \s-2JOVE\s0, ! 298: you can ignore this information. ! 299: .NH 2 ! 300: Prefix Characters ! 301: .XS \n(PN 5n ! 302: \*(SN Prefix Characters ! 303: .XE ! 304: .LP ! 305: Because there are more command names than keys, ! 306: \s-2JOVE\s0 provides ! 307: \fIprefix characters\fP to increase the number of commands that can ! 308: be invoked quickly and easily. ! 309: When you type a prefix character \s-2JOVE\s0 will wait ! 310: for another character before deciding what to do. ! 311: If you wait more than a second or so, ! 312: \s-2JOVE\s0 will print the prefix character on the ! 313: message line as a reminder and leave the cursor down there until you type your next ! 314: character. ! 315: There are two prefix characters built into \s-2JOVE\s0: ! 316: Escape and Control-X. ! 317: How the next character is interpreted depends on which ! 318: prefix character you typed. ! 319: For example, ! 320: if you type Escape followed by B you'll run \fIbackward-word\fP, ! 321: but if you type Control-X followed by B you'll run \fIselect-buffer\fP. ! 322: Elsewhere in this manual, the Escape key is indicated as "ESC", which is ! 323: also what \s-2JOVE\s0 displays on the message line for Escape. ! 324: .NH 2 ! 325: Help ! 326: .XS \n(PN ! 327: \*(SN Help ! 328: .XE ! 329: .LP ! 330: To get a list of keys and their associated commands, ! 331: you type ESC X \fIdescribe-bindings\fP. ! 332: If you want to describe a single key, ! 333: ESC X \fIdescribe-key\fP will work. A description of an ! 334: individual command is available by using ESC X \fIdescribe-command\fP, ! 335: and descriptions of variables by using ESC X \fIdescribe-variable\fP. ! 336: If you can't remember the name of the thing you want to know about, ! 337: ESC X \fIapropos\fP will tell you if a command or variable has a given ! 338: string in its name. For example, ESC X \fIapropos describe\fP will ! 339: list the names of the four describe commands mentioned briefly in this ! 340: section. ! 341: .NH 1 ! 342: Basic Editing Commands ! 343: .XS \n(PN ! 344: \*(SN Basic Editing Commands ! 345: .XE ! 346: .LP ! 347: .NH 2 ! 348: Inserting Text ! 349: .XS \n(PN 5n ! 350: \*(SN Inserting Text ! 351: .XE ! 352: .LP ! 353: To insert printing characters into the text you are editing, ! 354: just type them. ! 355: All printing characters you type are inserted into the text at ! 356: the cursor (that is, at \fIpoint\fP), ! 357: and the cursor moves forward. ! 358: Any characters after the cursor move forward too. ! 359: If the text in the buffer is FOOBAR, ! 360: with the cursor before the B, ! 361: then if you type XX, ! 362: you get FOOXXBAR, ! 363: with the cursor still before the B. ! 364: .LP ! 365: To correct text you have just inserted, ! 366: you can use Rubout. ! 367: Rubout deletes the character \fIbefore\fP the cursor (not the one that the ! 368: cursor is on top of or under; that is the character \fIafter\fP the ! 369: cursor). ! 370: The cursor and all characters after it move backwards. ! 371: Therefore, ! 372: if you typing a printing character and then type Rubout, ! 373: they cancel out. ! 374: .LP ! 375: To end a line and start typing a new one, ! 376: type Return. ! 377: Return operates by inserting a \fIline-separator\fP, ! 378: so if you type Return in ! 379: the middle of a line, ! 380: you break the line in two. ! 381: Because a line-separator is just a single character, ! 382: you can type Rubout at the ! 383: beginning of a line to delete the line-separator and join it with the ! 384: preceding line. ! 385: .LP ! 386: As a special case, if you type Return at the end of a line and there are ! 387: two or more empty lines just below it, \s-2JOVE\s0 does not insert a ! 388: line-separator but instead merely moves to the next (empty) line. This ! 389: behavior is convenient when you want to add several lines of text in the ! 390: middle of a buffer. You can use the Control-O (\fInewline-and-backup\fP) ! 391: command to "open" several empty lines at once; then you can insert the new ! 392: text, filling up these empty lines. The advantage is that \s-2JOVE\s0 does ! 393: not have to redraw the bottom part of the screen for each Return you type, ! 394: as it would ordinarily. That "redisplay" can be both slow and distracting. ! 395: .LP ! 396: If you add too many characters to one line, ! 397: without breaking it with Return, ! 398: the line will grow too long to display on one screen line. ! 399: When this happens, ! 400: \s-2JOVE\s0 puts an "!" at the extreme right margin, ! 401: and doesn't bother to display the rest of the line unless the ! 402: cursor happens to be in it. ! 403: The "!" is not part of your text; ! 404: conversely, ! 405: even though you can't see the rest of your line, ! 406: it's still there, ! 407: and if you break the line, ! 408: the "!" will go away. ! 409: .LP ! 410: Direct insertion works for printing characters and space, ! 411: but other ! 412: characters act as editing commands and do not insert themselves. ! 413: If you need to insert a control character, ! 414: Escape, ! 415: or Rubout, ! 416: you must first \fIquote\fP it by typing the Control-Q command first. ! 417: .NH 2 ! 418: Moving the Cursor ! 419: .XS \n(PN 5n ! 420: \*(SN Moving the Cursor ! 421: .XE ! 422: .LP ! 423: To do more than insert characters, ! 424: you have to know how to move the cursor. ! 425: Here are a few of the commands for doing that. ! 426: .IP "C-A" 15n ! 427: Move to the beginning of the line. ! 428: .IP "C-E" 15n ! 429: Move to the end of the line. ! 430: .IP "C-F" 15n ! 431: Move forward over one character. ! 432: .IP "C-B" 15n ! 433: Move backward over one character. ! 434: .IP "C-N" 15n ! 435: Move down one line, ! 436: vertically. ! 437: If you start in the middle of one line, ! 438: you end in the middle of the next. ! 439: .IP "C-P" 15n ! 440: Move up one line, ! 441: vertically. ! 442: .IP "ESC <" 15n ! 443: Move to the beginning of the entire buffer. ! 444: .IP "ESC >" 15n ! 445: Move to the end of the entire buffer. ! 446: .IP "ESC ," 15n ! 447: Move to the beginning of the visible window. ! 448: .IP "ESC ." 15n ! 449: Move to the end of the visible window. ! 450: .NH 2 ! 451: Erasing Text ! 452: .XS \n(PN 5n ! 453: \*(SN Erasing Text ! 454: .XE ! 455: .LP ! 456: .IP "Rubout" 15n ! 457: Delete the character before the cursor. ! 458: .IP "C-D" 15n ! 459: Delete the character after the cursor. ! 460: .IP "C-K" 15n ! 461: Kill to the end of the line. ! 462: .LP ! 463: You already know about the Rubout command which deletes the character ! 464: before the cursor. ! 465: Another command, ! 466: Control-D, ! 467: deletes the character ! 468: after the cursor, ! 469: causing the rest of the text on the line to shift left. ! 470: If Control-D is typed at the end of a line, ! 471: that line and the next line are joined together. ! 472: .LP ! 473: To erase a larger amount of text, ! 474: use the Control-K command, ! 475: which kills a line at a time. ! 476: If Control-K is done at the beginning or ! 477: middle of a line, ! 478: it kills all the text up to the end of the line. ! 479: If Control-K is done at the end of a line, ! 480: it joins that line and the next line. ! 481: If Control-K is done twice, it kills the rest of the line and the line ! 482: separator also. ! 483: .NH 2 ! 484: Files \(em Saving Your Work ! 485: .XS \n(PN 5n ! 486: \*(SN Files \(em Saving Your Work ! 487: .XE ! 488: .LP ! 489: The commands above are sufficient for creating text in the \s-2JOVE\s0 buffer. ! 490: The more advanced \s-2JOVE\s0 commands just make things easier. ! 491: But to keep any text permanently you must put it in a \fIfile\fP. ! 492: Files are the objects which ! 493: .UX ! 494: uses for storing data for a length of time. ! 495: To tell \s-2JOVE\s0 to read text into a file, ! 496: choose a filename, ! 497: such as \fIfoo.bar\fP, ! 498: and type C-X C-R \fIfoo.bar\fP<return>. ! 499: This reads the file \fIfoo.bar\fP so that its contents appear on the screen ! 500: for editing. ! 501: You can make changes, ! 502: and then save the file by typing C-X C-S (save-file). ! 503: This makes the changes permanent and actually changes the file \fIfoo.bar\fP. ! 504: Until then, ! 505: the changes are only inside \s-2JOVE\s0, ! 506: and the file \fIfoo.bar\fP is not really changed. ! 507: If the file \fIfoo.bar\fP doesn't exist, ! 508: and you want to create it, ! 509: read it as if it did exist. ! 510: When you save your text with C-X C-S the file will be created. ! 511: .NH 2 ! 512: Exiting and Pausing \(em Leaving \s-2JOVE\s0 ! 513: .XS \n(PN 5n ! 514: \*(SN Exiting and Pausing \(em Leaving \s-2JOVE\s0 ! 515: .XE ! 516: .LP ! 517: The command C-X C-C (\fIexit-jove\fP) will terminate the \s-2JOVE\s0 ! 518: session and return to the shell. If there are modified but ! 519: unsaved buffers, \s-2JOVE\s0 will ask you for confirmation, and you ! 520: can abort the command, look at what buffers are ! 521: modified but unsaved using C-X C-B (\fIlist-buffers\fP), save the ! 522: valuable ones, and then exit. If what you want to do, on the other hand, ! 523: is \fIpreserve\fP the editing session but return to the shell temporarily ! 524: you can (under Berkeley ! 525: .UX ! 526: only) issue the command ESC S (\fIpause-jove\fP), do your ! 527: .UX ! 528: work within the c-shell, then return to \s-2JOVE\s0 using the ! 529: \fIfg\fP command to resume editing at the point where you paused. ! 530: For this sort of situation you might consider using an \fIinteractive ! 531: shell\fP (that is, a shell in a \s-2JOVE\s0 window) which lets you use ! 532: editor commands to manipulate your ! 533: .UX ! 534: commands (and their output) while never leaving the editor. ! 535: (The interactive shell feature is described below.) ! 536: .NH 2 ! 537: Giving Numeric Arguments to \s-2JOVE\s0 Commands ! 538: .XS \n(PN 5n ! 539: \*(SN Giving Numeric Arguments to \s-2JOVE\s0 Commands ! 540: .XE ! 541: .LP ! 542: Any \s-2JOVE\s0 command can be given a \fInumeric argument\fP. ! 543: Some commands interpret the argument as a repetition count. ! 544: For example, ! 545: giving an argument of ten to the C-F command (forward-character) moves forward ! 546: ten characters. ! 547: With these commands, ! 548: no argument is equivalent to an argument of 1. ! 549: .LP ! 550: Some commands use the value of the argument, ! 551: but do something peculiar (or nothing) when there is no argument. ! 552: For example, ! 553: ESC G (\fIgoto-line\fP) with an argument \fBn\fP ! 554: goes to the beginning of the \fBn\fP'th line. ! 555: But ESC G with no argument doesn't do anything. ! 556: Similarly, C-K with an argument kills that many lines, including their line ! 557: separators. Without an argument, C-K when there is text on the line to the ! 558: right of ! 559: the cursor kills that text; when there is no text after the cursor, C-K ! 560: deletes the line separator. ! 561: .LP ! 562: The fundamental way of specifying an argument is to use ESC followed ! 563: by the digits of the argument, for example, ESC 123 ESC G to go to line ! 564: 123. Negative arguments are allowed, ! 565: although not all of the commands know what to do with one. ! 566: .LP ! 567: Typing C-U means do the next command four times. ! 568: Two such C-U's multiply the next command by sixteen. ! 569: Thus, ! 570: C-U C-U C-F moves forward sixteen characters. ! 571: This is a good way to move forward quickly, ! 572: since it moves about 1/4 of a line on most terminals. ! 573: Other useful combinations are: ! 574: C-U C-U C-N (move down a good fraction of the screen), ! 575: C-U C-U C-O (make "a lot" of blank lines), ! 576: and C-U C-K (kill four lines \(em note that typing C-K four times ! 577: would kill 2 lines). ! 578: .LP ! 579: There are other, ! 580: terminal-dependent ways of specifying arguments. ! 581: They have the same effect but may be easier to type. ! 582: If your terminal ! 583: has a numeric keypad which sends something recognizably different from ! 584: the ordinary digits, ! 585: it is possible to program \s-2JOVE\s0 to to allow use of ! 586: the numeric keypad for specifying arguments. ! 587: .NH 2 ! 588: The Mark and the Region ! 589: .XS \n(PN 5n ! 590: \*(SN The Mark and the Region ! 591: .XE ! 592: .LP ! 593: In general, ! 594: a command that processes an arbitrary part of the buffer ! 595: must know where to start and where to stop. ! 596: In \s-2JOVE\s0, ! 597: such commands usually operate on the text between point and \fIthe mark\fP. ! 598: This body of text is called \fIthe region\fP. ! 599: To specify a region, ! 600: you set point to one end of it and mark at the other. ! 601: It doesn't matter which one comes earlier in the text. ! 602: .IP "C-@" 15n ! 603: Set the mark where point is. ! 604: .IP "C-X C-X" 15n ! 605: Interchange mark and point. ! 606: .LP ! 607: For example, ! 608: if you wish to convert part of the buffer to all upper-case, ! 609: you can use the C-X C-U command, ! 610: which operates on the text in the region. ! 611: You can first go to the beginning of the text to be capitalized, ! 612: put the mark there, move to the end, and then type C-X C-U. ! 613: Or, ! 614: you can set the mark at the end of the text, ! 615: move to the beginning, ! 616: and then type C-X C-U. ! 617: C-X C-U runs the command \fIcase-region-upper\fP, ! 618: whose name signifies that the region, ! 619: or everything between point and mark, ! 620: is to be capitalized. ! 621: .LP ! 622: The way to set the mark is with the C-@ command or (on some ! 623: terminals) the C-Space command. ! 624: They set the mark where point is. ! 625: Then you can move point away, ! 626: leaving mark behind. When the mark is set, "[Point pushed]" is printed on ! 627: the message line. ! 628: .LP ! 629: Since terminals have only one cursor, ! 630: there is no way for \s-2JOVE\s0 to show you where the mark is located. ! 631: You have to remember. ! 632: The usual solution to this problem is to set the mark and then use it soon, ! 633: before you forget where it is. ! 634: But you can see where the mark is with ! 635: the command C-X C-X which puts the mark where point was and point ! 636: where mark was. ! 637: The extent of the region is unchanged, ! 638: but the cursor and point are now at the previous location of the mark. ! 639: .NH 2 ! 640: The Ring of Marks ! 641: .XS \n(PN 5n ! 642: \*(SN The Ring of Marks ! 643: .XE ! 644: .LP ! 645: Aside from delimiting the region, ! 646: the mark is also useful for remembering a spot that you may want to go back to. ! 647: To make this feature more useful, ! 648: \s-2JOVE\s0 remembers 16 previous locations of the mark. ! 649: Most commands that set the mark push the old mark onto this stack. ! 650: To return to a marked location, use C-U C-@. ! 651: This moves point to where the mark was, ! 652: and restores the mark from the stack of former marks. ! 653: So repeated use of this command moves point to all of the old ! 654: marks on the stack, ! 655: one by one. ! 656: Since the stack is actually a ring, ! 657: enough uses of C-U C-@ bring point back to where it was originally. ! 658: .LP ! 659: Some commands whose primary purpose is to move point a great distance ! 660: take advantage of the stack of marks to give you a way to undo the ! 661: command. ! 662: The best example is ESC <, ! 663: which moves to the beginning of the buffer. ! 664: If there are more than 22 lines between the beginning of ! 665: the buffer and point, ! 666: ESC < sets the mark first, ! 667: so that you can use C-U C-@ or C-X C-X to go back to where you were. ! 668: You can change the number of lines from 22 since it is kept in the variable \fImark-threshold\fP. ! 669: By setting it to 0, ! 670: you can make these commands always set the mark. ! 671: By setting it to a very large number you can prevent these commands from ever ! 672: setting the mark. ! 673: If a command decides to set the mark, ! 674: it prints the message \fI[Point pushed]\fP. ! 675: .NH 2 ! 676: Killing and Moving Text ! 677: .XS \n(PN 5n ! 678: \*(SN Killing and Moving Text ! 679: .XE ! 680: .LP ! 681: The most common way of moving or copying text with \s-2JOVE\s0 is to kill it, ! 682: and get it back again in one or more places. ! 683: This is very safe ! 684: because the last several pieces of killed text are all remembered, ! 685: and it is versatile, ! 686: because the many commands for killing syntactic units ! 687: can also be used for moving those units. ! 688: There are also other ways of moving text for special purposes. ! 689: .NH 2 ! 690: Deletion and Killing ! 691: .XS \n(PN 5n ! 692: \*(SN Deletion and Killing ! 693: .XE ! 694: .LP ! 695: Most commands which erase text from the buffer save it so that you can ! 696: get it back if you change your mind, ! 697: or move or copy it to other parts of the buffer. ! 698: These commands are known as \fIkill\fP commands. ! 699: The rest of the commands that erase text do not save it; ! 700: they are known as \fIdelete\fP commands. ! 701: The delete commands include C-D and Rubout, ! 702: which delete only one character at a time, ! 703: and those commands that delete only spaces or line separators. ! 704: Commands that can destroy significant amounts of nontrivial data generally kill. ! 705: A command's ! 706: name and description will use the words \fIkill\fP or \fIdelete\fP to ! 707: say which one it does. ! 708: .IP "C-D" 20n ! 709: Delete next character. ! 710: .IP "Rubout" 20n ! 711: Delete previous character. ! 712: .IP "ESC \\\\\\\\" 20n ! 713: Delete spaces and tabs around point. ! 714: .IP "C-X C-O" 20n ! 715: Delete blank lines around the current line. ! 716: .IP "C-K" 20n ! 717: Kill rest of line or one or more lines. ! 718: .IP "C-W" 20n ! 719: Kill region (from point to the mark). ! 720: .IP "ESC D" 20n ! 721: Kill word. ! 722: .IP "ESC Rubout" 20n ! 723: Kill word backwards. ! 724: .IP "ESC K" 20n ! 725: Kill to end of sentence. ! 726: .IP "C-X Rubout" 20n ! 727: Kill to beginning of sentence. ! 728: .NH 2 ! 729: Deletion ! 730: .XS \n(PN 5n ! 731: \*(SN Deletion ! 732: .XE ! 733: .LP ! 734: The most basic delete commands are C-D and Rubout. ! 735: C-D deletes the character after the cursor, ! 736: the one the cursor is "on top of" or "underneath". ! 737: The cursor doesn't move. ! 738: Rubout deletes the character before the cursor, ! 739: and moves the cursor back. ! 740: Line separators act like normal characters when deleted. ! 741: Actually, ! 742: C-D and Rubout aren't always \fIdelete\fP commands; ! 743: if you give an argument, ! 744: they \fIkill\fP instead. ! 745: This prevents you from losing a great deal of text by typing a large ! 746: argument to a C-D or Rubout. ! 747: .LP ! 748: The other delete commands are those which delete only formatting ! 749: characters: ! 750: spaces, ! 751: tabs, ! 752: and line separators. ! 753: ESC \\ (\fIdelete-white-space\fP) ! 754: deletes all the spaces and tab characters before and after point. ! 755: C-X C-O (\fIdelete-blank-lines\fP) deletes all blank lines after the current line, ! 756: and if the current line is blank deletes all the blank ! 757: lines preceding the current line as well ! 758: (leaving one blank line, the current line). ! 759: .NH 2 ! 760: Killing by Lines ! 761: .XS \n(PN 5n ! 762: \*(SN Killing by Lines ! 763: .XE ! 764: .LP ! 765: The simplest kill command is the C-K command. ! 766: If issued at the beginning of a line, ! 767: it kills all the text on the line, ! 768: leaving it blank. ! 769: If given on a line containing only white space (blanks and tabs) ! 770: the line disappears. ! 771: As a consequence, ! 772: if you go to the front of a non-blank line and type two C-K's, ! 773: the line disappears completely. ! 774: .LP ! 775: More generally, ! 776: C-K kills from point up to the end of the line, ! 777: unless it is at the end of a line. ! 778: In that case, ! 779: it kills the line separator following the line, ! 780: thus merging the next line into the current one. ! 781: Invisible spaces and tabs at the end of the line are ignored when ! 782: deciding which case applies, ! 783: so if point appears to be at the end of the line, ! 784: you can be sure the line separator will be killed. ! 785: .LP ! 786: C-K with an argument of zero kills all the text before ! 787: point on the current line. ! 788: .NH 2 ! 789: Other Kill Commands ! 790: .XS \n(PN 5n ! 791: \*(SN Other Kill Commands ! 792: .XE ! 793: .LP ! 794: A kill command which is very general is C-W (\fIkill-region\fP), ! 795: which kills everything between point and the mark.* ! 796: .FS ! 797: *Often users switch this binding from C-W to C-X C-K because it is too ! 798: easy to hit C-W accidentally. ! 799: .FE ! 800: With this command, ! 801: you can kill and save contiguous characters, ! 802: if you first set the mark at one end of them and go to the other end. ! 803: .LP ! 804: Other syntactic units can be killed, too; ! 805: words, ! 806: with ESC Rubout and ESC D; ! 807: and, sentences, ! 808: with ESC K and C-X Rubout. ! 809: .NH 2 ! 810: Un-killing ! 811: .XS \n(PN 5n ! 812: \*(SN Un-killing (Yanking) ! 813: .XE ! 814: .LP ! 815: Un-killing (yanking) is getting back text which was killed. ! 816: The usual way to ! 817: move or copy text is to kill it and then un-kill it one or more times. ! 818: .IP "C-Y" 10n ! 819: Yank (re-insert) last killed text. ! 820: .IP "ESC Y" 10n ! 821: Replace re-inserted killed text with the previously killed text. ! 822: .IP "ESC W" 10n ! 823: Save region as last killed text without killing. ! 824: .LP ! 825: Killed text is pushed onto a \fIring buffer\fP called the \fIkill ! 826: ring\fP that remembers the last 10 blocks of text that were killed. ! 827: (Why it is called a ring buffer will be explained below). ! 828: The command C-Y (\fIyank\fP) reinserts the text of the most recent kill. ! 829: It leaves the cursor at the end of the text, ! 830: and puts the mark at the beginning. ! 831: Thus, ! 832: a single C-Y undoes the C-W. ! 833: .LP ! 834: If you wish to copy a block of text, ! 835: you might want to use ESC W (\fIcopy-region\fP), ! 836: which copies the region into the kill ring without removing it from the buffer. ! 837: This is approximately equivalent to C-W followed by C-Y, ! 838: except that ESC W does not mark the buffer as ! 839: "changed" and does not cause the screen to be rewritten. ! 840: .LP ! 841: There is only one kill ring shared among all the buffers. ! 842: After visiting a new file, ! 843: whatever was last killed in the previous file is still on top of the kill ring. ! 844: This is important for moving text between files. ! 845: .NH 2 ! 846: Appending Kills ! 847: .XS \n(PN 5n ! 848: \*(SN Appending Kills ! 849: .XE ! 850: .LP ! 851: Normally, ! 852: each kill command pushes a new block onto the kill ring. ! 853: However, ! 854: two or more kill commands immediately in a row (without any other ! 855: intervening commands) combine their text into a ! 856: single entry on the ring, ! 857: so that a single C-Y command gets it all back as it was before it was killed. ! 858: This means that you don't have to kill all the text in one command; ! 859: you can keep killing line after line, ! 860: or word after word, ! 861: until you have killed it all, ! 862: and you can still get it all back at once. ! 863: .LP ! 864: Commands that kill forward from ! 865: .I point ! 866: add onto the end of the previous ! 867: killed text. ! 868: Commands that kill backward from ! 869: .I point ! 870: add onto the beginning. ! 871: This way, ! 872: any sequence of mixed forward and backward kill ! 873: commands puts all the killed text into one entry without needing rearrangement. ! 874: .NH 2 ! 875: Un-killing Earlier Kills ! 876: .XS \n(PN 5n ! 877: \*(SN Un-killing Earlier Kills ! 878: .XE ! 879: .LP ! 880: To recover killed text that is no longer the most recent kill, ! 881: you need the ESC Y (\fIyank-pop\fP) command. ! 882: The ESC Y command can be used ! 883: only after a C-Y (yank) command or another ESC Y. ! 884: It takes the un-killed ! 885: text inserted by the C-Y and replaces it with the text from an earlier ! 886: kill. ! 887: So, ! 888: to recover the text of the next-to-the-last kill, ! 889: you first use C-Y to recover the last kill, ! 890: and then discard it by use of ESC Y to move back to the previous kill. ! 891: .LP ! 892: You can think of all the last few kills as living on a ring. ! 893: After a C-Y command, ! 894: the text at the front of the ring is also present in the buffer. ! 895: ESC Y "rotates" the ring bringing the previous string of text to the front ! 896: and this text replaces the other text in the buffer as well. ! 897: Enough ESC Y commands can rotate any part of the ring to the front, ! 898: so you can get at any killed text so long as it is recent enough ! 899: to be still in the ring. ! 900: Eventually the ring rotates all the way ! 901: around and the most recently killed text comes to the front ! 902: (and into the buffer) again. ! 903: ESC Y with a negative argument rotates the ring backwards. ! 904: .LP ! 905: When the text you are looking for is brought into the buffer, ! 906: you can stop doing ESC Y's and the text will stay there. ! 907: It's really just a copy of what's at the front of the ring, ! 908: so editing it does not change what's in the ring. ! 909: And the ring, ! 910: once rotated, ! 911: stays rotated, ! 912: so that doing another C-Y gets another copy of what you rotated to the ! 913: front with ESC Y. ! 914: .LP ! 915: If you change your ! 916: mind about un-killing, ! 917: C-W gets rid of the un-killed text, even ! 918: after any number of ESC Y's. ! 919: .NH 1 ! 920: Searching ! 921: .XS \n(PN ! 922: \*(SN Searching ! 923: .XE ! 924: .LP ! 925: The search commands are useful for finding and moving to arbitrary ! 926: positions in the buffer in one swift motion. ! 927: For example, ! 928: if you just ran the spell program on a paper ! 929: and you want to correct some word, ! 930: you can use the search commands to move directly to that word. There are ! 931: two flavors of search: \fIstring search\fP and \fIincremental search\fP. ! 932: The former is the default flavor\(emif you want to use incremental search ! 933: you must rearrange the key bindings (see below). ! 934: .NH 2 ! 935: Conventional Search ! 936: .XS \n(PN 5n ! 937: \*(SN Conventional Search ! 938: .XE ! 939: .LP ! 940: .IP "C-S" 15n ! 941: Search forward. ! 942: .IP "C-R" 15n ! 943: Search backward. ! 944: .LP ! 945: To search for the string "FOO" you type "C-S FOO<return>". ! 946: If \s-2JOVE\s0 finds ! 947: FOO it moves point to the end of it; otherwise \s-2JOVE\s0 prints an error ! 948: message and leaves point unchanged. ! 949: C-S searches forward from point ! 950: so only occurrences of FOO after point are found. ! 951: To search in the other direction use C-R. ! 952: It is exactly the same as C-S except it searches in the opposite direction, ! 953: and if it finds the string, ! 954: it leaves point at the beginning of it, ! 955: not at the end as in C-S. ! 956: .LP ! 957: While \s-2JOVE\s0 is searching it prints the search string on the message line. ! 958: This is so you know what \s-2JOVE\s0 is doing. ! 959: When the system is heavily loaded and ! 960: editing in exceptionally large buffers, ! 961: searches can take several (sometimes many) seconds. ! 962: .LP ! 963: \s-2JOVE\s0 remembers the last search string you used, ! 964: so if you want to search for the same string you can type "C-S <return>". ! 965: If you mistyped the last search string, ! 966: you can type C-S followed by C-R. ! 967: C-R, ! 968: as usual, ! 969: inserts the default search string into the minibuffer, ! 970: and then you can fix it up. ! 971: .NH 2 ! 972: Incremental Search ! 973: .XS \n(PN 5n ! 974: \*(SN Incremental Search ! 975: .XE ! 976: .LP ! 977: This search command is unusual in that is is \fIincremental\fP; ! 978: it begins to search before you have typed the complete search string. ! 979: As you type in the search string, ! 980: \s-2JOVE\s0 shows you where it would be found. ! 981: When you have typed enough characters to identify the place you want, ! 982: you can stop. ! 983: Depending on what you will do next, ! 984: you may or may not need to terminate the search explicitly with a Return first. ! 985: .LP ! 986: The command to search is C-S (\fIi-search-forward\fP). ! 987: C-S reads in characters and positions the cursor at the first ! 988: occurrence of the characters that you have typed so far. ! 989: If you type C-S and then F, ! 990: the cursor moves in the text just after the next "F". ! 991: Type an "O", ! 992: and see the cursor move to after the next "FO". ! 993: After another "O", ! 994: the cursor is after the next "FOO". ! 995: At the same time, ! 996: the "FOO" has echoed on the message line. ! 997: .LP ! 998: If you type a mistaken character, ! 999: you can rub it out. ! 1000: After the FOO, ! 1001: typing a Rubout makes the "O" disappear from the message line, ! 1002: leaving only "FO". ! 1003: The cursor moves back in the buffer to the "FO". ! 1004: Rubbing out the "O" and "F" moves the cursor back to where you ! 1005: started the search. ! 1006: .LP ! 1007: When you are satisfied with the place you have reached, ! 1008: you can type a Return, ! 1009: which stops searching, ! 1010: leaving the cursor where the search brought it. ! 1011: Also, ! 1012: any command not specially meaningful in searches stops ! 1013: the searching and is then executed. ! 1014: Thus, ! 1015: typing C-A would exit the search and then move to the beginning of the line. ! 1016: Return is necessary only if the next character you want to type is a printing ! 1017: character, ! 1018: Rubout, ! 1019: Return, ! 1020: or another search command, ! 1021: since those are the characters that have special meanings inside the search. ! 1022: .LP ! 1023: Sometimes you search for "FOO" and find it, ! 1024: but not the one you hoped to find. ! 1025: Perhaps there is a second FOO that you forgot about, ! 1026: after the one you just found. ! 1027: Then type another C-S and the cursor will find the next FOO. ! 1028: This can be done any number of times. ! 1029: If you overshoot, ! 1030: you can return to previous finds by rubbing out the C-S's. ! 1031: .LP ! 1032: After you exit a search, ! 1033: you can search for the same string again by typing just C-S C-S: ! 1034: one C-S command to start the search and then ! 1035: another C-S to mean "search again for the same string". ! 1036: .LP ! 1037: If your string is not found at all, ! 1038: the message line says "Failing I-search". ! 1039: The cursor is after the place where \s-2JOVE\s0 found as much of ! 1040: your string as it could. ! 1041: Thus, ! 1042: if you search for FOOT and there is no FOOT, ! 1043: you might see the cursor after the FOO in FOOL. ! 1044: At this point there are several things you can do. ! 1045: If your string was mistyped, ! 1046: you can rub some of it out and correct it. ! 1047: If you like the place you have found, ! 1048: you can type Return or some other \s-2JOVE\s0 command ! 1049: to "accept what the search offered". ! 1050: Or you can type C-G, ! 1051: which undoes the search altogether and positions you back where you started ! 1052: the search. ! 1053: .LP ! 1054: You can also type C-R at any time to start searching backwards. ! 1055: If a search fails because the place you started was too late in the file, ! 1056: you should do this. ! 1057: Repeated C-R's keep looking backward for more occurrences of the last search string. ! 1058: A C-S starts going forward again. ! 1059: C-R's can be rubbed out just like anything else. ! 1060: .NH 2 ! 1061: Searching with Regular Expressions ! 1062: .XS \n(PN 5n ! 1063: \*(SN Searching with Regular Expressions ! 1064: .XE ! 1065: .LP ! 1066: In addition to the searching facilities described above, ! 1067: \s-2JOVE\s0 ! 1068: can search for patterns using regular expressions. ! 1069: The handling of regular expressions in \s-2JOVE\s0 is like that of \fIed(1)\fP ! 1070: or \fIvi(1)\fP, but with some notable additions. ! 1071: The extra metacharacters understood by \s-2JOVE\s0 are \e<, ! 1072: \e>, ! 1073: \e\|| and \e\|{. ! 1074: The first two of these match the beginnings and endings of words; ! 1075: Thus the search pattern, ! 1076: "\|\e<Exec" would match all words beginning with the letters "Exec". ! 1077: .LP ! 1078: An \e\|| signals the beginning of an alternative \(em that is, the ! 1079: pattern "foo\e\||bar" would match either "foo" or "bar". The "curly ! 1080: brace" is a way of introducing several sub-alternatives into a pattern. ! 1081: It parallels the [] construct of regular expressions, except it specifies ! 1082: a list of alternative words instead of just alternative characters. So ! 1083: the pattern "foo\e\|{bar,baz\e\|}bie" matches "foobarbie" or "foobazbie". ! 1084: .LP ! 1085: \s-2JOVE\s0 only regards metacharacters as special if the variable ! 1086: \fImatch-regular-expressions\fP is set to "on". ! 1087: The ability to have \s-2JOVE\s0 ignore these characters is useful if ! 1088: you're editing a document about patterns and regular expressions or ! 1089: when a novice is learning \s-2JOVE\s0. ! 1090: .LP ! 1091: Another variable that affects searching is \fIcase-ignore-search\fP. If ! 1092: this variable is set to "on" then upper case and lower case letters are ! 1093: considered equal. ! 1094: .NH 1 ! 1095: Replacement Commands ! 1096: .XS \n(PN ! 1097: \*(SN Replacement Commands ! 1098: .XE ! 1099: .LP ! 1100: Global search-and-replace operations are not needed as often in \s-2JOVE\s0 ! 1101: as they are in other editors, ! 1102: but they are available. ! 1103: In addition to ! 1104: the simple Replace operation which is like that found in most editors, ! 1105: there is a Query Replace operation which asks, ! 1106: for each occurrence of the pattern, ! 1107: whether to replace it. ! 1108: .NH 2 ! 1109: Global replacement ! 1110: .XS \n(PN 5n ! 1111: \*(SN Global Replacement ! 1112: .XE ! 1113: .LP ! 1114: To replace every occurrence of FOO after point with BAR, ! 1115: you can do, e.g., "ESC R FOO<return>BAR" as the \fIreplace-string\fP command ! 1116: is bound to the ESC R. ! 1117: Replacement takes place only between point and the end of the buffer ! 1118: so if you want to cover the whole buffer you must go to the beginning first. ! 1119: .NH 2 ! 1120: Query Replace ! 1121: .XS \n(PN 5n ! 1122: \*(SN Query Replace ! 1123: .XE ! 1124: .LP ! 1125: If you want to change only some of the occurrences of FOO, ! 1126: not all, ! 1127: then the global \fIreplace-string\fP is inappropriate; ! 1128: Instead, ! 1129: use, e.g., "ESC Q FOO<return>BAR", to run the command \fIquery-replace-string\fP. ! 1130: This displays each occurrence of FOO and waits for you to say whether ! 1131: to replace it with a BAR. ! 1132: The things you can type when you are shown an occurrence of FOO are: ! 1133: .IP "Space" 15n ! 1134: to replace the FOO. ! 1135: .IP "Rubout" 15n ! 1136: to skip to the next FOO without replacing this one. ! 1137: .IP "Return" 15n ! 1138: to stop without doing any more replacements. ! 1139: .IP "Period" 15n ! 1140: to replace this FOO and then stop. ! 1141: .IP "! or P" 15n ! 1142: to replace all remaining FOO's without asking. ! 1143: .IP "C-R or R" 15n ! 1144: to enter a recursive editing level, ! 1145: in case the FOO needs to be edited rather than just replaced with a BAR. ! 1146: When you are done, ! 1147: exit the recursive editing level with C-X C-C and the next FOO will ! 1148: be displayed. ! 1149: .IP "C-W" 15n ! 1150: to delete the FOO, and then start editing the buffer. ! 1151: When you are finished editing whatever is to replace the FOO, ! 1152: exit the recursive editing level with C-X C-C ! 1153: and the next FOO will be displayed. ! 1154: .IP "U" 15n ! 1155: move to the last replacement and undo it. ! 1156: .LP ! 1157: Another alternative is using \fIreplace-in-region\fP which is just like ! 1158: \fIreplace-string\fP except it searches only within the region. ! 1159: .LP
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.