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