43BSD/contrib/jove/doc/manual.n - annotate

Return to manual.n CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / jove / doc

Annotation of 43BSD/contrib/jove/doc/manual.n, revision 1.1.1.1

1.1 root 1: .de eg
2: .ti .5i
3: .sp 1
4: .bo \\$1
5: .sp 1
6: ..
7: .de ks
8: .sp
9: .ta .5i \\$1
10: .in \\$1
11: ..
12: .de dk \" Describe Key
13: .ti 0
14: \t\\$1\t\c \" Flow into the paragraph
15: ..
16: .de ke \" Key list End
17: .in 0
18: ..
19: .nr si 3n
20: .st 2
21: .m1 3
22: .m4 0
23: .he '%''JOVE Manual for UNIX Users'
24: .bs "Introduction"
25: JOVE
26: .fb
27: JOVE stands for Jonathan's Own Version of Emacs.
28: .fe
29: is an advanced, self-documenting, customizable real-time display
30: editor. It is based on the original EMACS editor written at M.I.T.
31: by Richard Stallman.
32: .fb
33: Although JOVE is meant to be compatible with
34: EMACS, and indeed many of the basic commands are very similar, there
35: are some major differences between the two editors, and you should not
36: rely on their behaving identically.
37: .fe
38: .lp
39: We say that JOVE is a display editor because normally the text being
40: edited is visible on the screen and is updated automatically as you
41: type your commands.
42: .lp
43: We call it a real-time editor because the display is updated very
44: frequently, usually after each character or pair of characters you
45: type. This minimizes the amount of information you must keep in your
46: head as you edit.
47: .lp
48: We call JOVE advanced because it provides facilities that go beyond
49: simple insertion and deletion: filling of text; automatic indentations
50: of programs; view more than one file at once; and dealing in terms of
51: characters, words, lines, sentences and paragraphs. It is much easier
52: to type one command meaning "go to the end of the paragraph" than to
53: find the desired spot with repetition of simpler commands.
54: .lp
55: Self-documenting means that at almost any time you can type a key to
56: find out what a command does, or to find all the commands that pertain
57: to a topic.
58: .lp
59: Customizable means that you can change the definition of JOVE commands
60: in little ways. For example, you can rearrange the command set; if
61: you prefer to use arrow keys for the four basic cursor motion commands
62: (up, down, left and right), you can. Another sort of customization is
63: writing new commands by combining built in commands.
64: .es
65: .bs "The Organization of the Screen"
66: JOVE divides the screen up into several sections. The biggest of
67: these sections is used to display the text you
68: are editing. The terminal's cursor shows the position of \fIpoint\fR,
69: the location at which editing takes place. While the cursor appears
70: to point \fIat\fR a character, point should be thought of as between
71: characters; it points \fIbefore\fR the character that the cursor
72: appears on top of. Terminals have only one cursor, and when output is
73: in progress it must appear where the typing is being done. This
74: doesn't mean that point is moving; it is only that JOVE has no way of
75: showing you the location of point except when the terminal is idle.
76: .lp
77: The lines of the screen are usually available for displaying text but
78: sometimes are pre-empted by typeout from certain commands (such as, a
79: listing of all the editor functions). Most of the time, output from
80: commands like these is only desired for a short period of time,
81: usually just long enough to glance at it. When you have finished
82: looking at the output, you can type Space to make your text reappear.
83: (Usually typing a Space inserts itself, but when there is typeout on
84: the screen, it does nothing but get rid of that.) Any other command
85: executes normally, \fIafter\fR redrawing your text.
86: .bs "The Message Line"
87: The bottom line on the screen, called the \fImessage line\fR is
88: reserved for printing messages, and for accepting input from the user,
89: such as file names, or search strings. When JOVE prompts for input,
90: the cursor will temporarily appear on the bottom line, waiting for you
91: to type a string. When you have finished typing your input, you can
92: type a Return to send it to JOVE. If you change your mind about
93: running the command that is waiting for input, you can type ^G to
94: abort, and you can continue with your editing.
95: .lp
96: Sometimes you will see --more-- on the message line. This happens
97: when typeout from a command is too long to fit in the screen. It
98: means that if you type a Space the next screenful of typeout will be
99: printed. If you are not interested, typing anything but a Space will
100: cause the rest of the output to be discarded. Typing C-G will discard
101: the output and print Aborted where the --more-- was. Typing any other
102: command will discard the rest of the output and also do the command.
103: .es
104: .bs "The Mode Line"
105: At the bottom of the screen, but above the message line, is the
106: \fImode line\fR. The mode line format looks like this:
107: .sp 1
108: \fBJOVE (major minor) Buffer: bufr "file" *\fR
109: .sp 1
110: \fImajor\fR is the name of the current \fImajor mode\fR. At any time,
111: JOVE can be in only one of the possible major modes. Currently there
112: are only two major modes: Text and C.
113: .lp
114: \fIminor\fR is a list of the minor modes that are turned. "Fill"
115: means that Auto Fill mode is on; "Save" means Auto Save mode is on;
116: "OvrWt" means that Over Write mode is on. "Def" means that you are in
117: the process of defining a keyboard macro. This is not really a mode,
118: but it's useful to be reminded about.
119: .lp
120: \fIbufr\fR is the name of the currently selected \fIbuffer\fR.
121: Each buffer has its own name and holds a file being edited; this is
122: how JOVE can hold several files at once. But at any given time you
123: are editing only one of them, the \fIselected\fR buffer. When we
124: speak of what some command does to "the buffer", we are talking about
125: the currently selected buffer. Multiple buffers makes it easy to
126: switch around between several files, and then it is very useful that
127: the mode line tells you which one you are editing at any time.
128: .lp
129: \fIfile\fR is the name of the file that you are editing. This is the
130: default file name for commands that expect a file name as input.
131: .lp
132: The star at the end of the mode line means that there are changes in
133: the buffer that have not been saved in the file. If the file has not
134: been changed since it was read in or saved, there is no star.
135: .es
136: .es
137: .bs "Command Input Conventions"
138: .bs "Notational Conventions for ASCII Characters"
139: In this manual, "Control" characters (that is, characters that are
140: typed with the Control key and some other key at the same time) are
141: represented by "C-" followed by another character. Thus, C-A is the
142: character you get when you type A with the Control key (sometimes
143: labeled CTRL) down. Most control characters when present in the JOVE
144: buffer are displayed with a caret; thus, ^A for C-A. Rubout is
145: displayed as ^?.
146: .es
147: .bs "Commands, Functions, and Variables"
148: JOVE is composed of \fIfunctions\fR, which have long names such as
149: "next-line" and definitions which are programs that perform the
150: editing operations. Then \fIcommands\fR such as C-N are connected to
151: functions through the \fIcommand dispatch table\fR. When we say that
152: C-N moves the cursor down a line, we are glossing over a distinction
153: which is unimportant for ordinary use, but essential for simple
154: customization: it is the function next-line which knows how to move
155: down a line, and C-N moves down a line because it is connected to that
156: function.
157: .lp
158: Sometimes the description of a command will say "to change this, set
159: the variable mumble foo". A variable is a name used to remember a
160: value. JOVE contains variables which are there so that you can change
161: them if you want to customize. The variable's value is examined by
162: some command, and changing that value makes the command behave
163: differently. Until you are interesting in customizing, you can ignore
164: this information.
165: .es
166: .bs "Prefix Characters"
167: Because there are more function names than keys, JOVE provides
168: \fIprefix characters\fR to increase the number of functions that can
169: easily be invoked. When you type a prefix character JOVE will wait
170: for another character before deciding what to do. If you wait more
171: than a second or so, JOVE will print the prefix character on the
172: message line and leave the cursor down there until you type your next
173: character. There are two prefix characters built into JOVE: Escape
174: and Control-X. How the next character is interpreted depends on which
175: prefix character you typed. For example, if you type Escape followed
176: by F you'll run forward-word, but if you type Control-X followed by
177: B you'll run select-buffer.
178: .lp
179: To get a list of keys and their associated function, you type ESC X
180: describe-bindings. If you want to describe a single key, ESC X
181: describe-key will work.
182: .es
183: .es
184: .bs "Basic Editing Commands"
185: .bs "Inserting Text"
186: To insert printing characters into the text you are editing, just type
187: them. All printing characters your type are inserted into the text at
188: the cursor (that is, at \fIpoint\fR), and the cursor moves forward.
189: Any characters after the cursor move forward too. If the text in the
190: buffer is FOOBAR, with the cursor before the B, then if you type XX,
191: you get FOOXXBAR, with the cursor still before the B.
192: .lp
193: To correct text you have just inserted, you can use Rubout. Rubout
194: deletes the character \fIbefore\fR the cursor (not the one that the
195: cursor is on top of or under; that is the character \fIafter\fR the
196: cursor). The cursor and all characters after it move backwards.
197: Therefore, if you typing a printing character and then type Rubout,
198: they cancel out.
199: .lp
200: To end a line and start typing a new one, type Return. Return
201: operates by inserting a \fIline-separator\fR, so if you type Return in
202: the middle of a line, you break the line in two. Because a
203: line-separator is just a single character, you can type Rubout at the
204: beginning of a line to delete the line-separator and join it with the
205: preceding line.
206: .lp
207: If you add too many characters to one line, without breaking it with
208: Return, the line will grow too long to display on one screen line.
209: When this happens, JOVE puts an "!" at the extreme right margin, and
210: doesn't bother to display the rest of the line. The "!" is not part
211: of your text; conversely, even though you can't see the rest of your
212: line, it's still there, and if you break the line, the "!" will go
213: away.
214: .lp
215: Direct insertion works for printing characters and space, but other
216: characters act as editing commands and do not insert themselves. If
217: you need to insert a control character, Escape, or Rubout, you must
218: first \fIquote\fR it by typing the Control-Q command first.
219: .es
220: .bs "Moving the Cursor"
221: To do more than insert characters, you have to know how to move the
222: cursor. Here are a few of the commands for doing that.
223: .ks 1.5i
224: .dk C-A
225: Move to the beginning of the line.
226: .dk C-E
227: Move to the end of the line.
228: .dk C-F
229: Move forward over one character.
230: .dk C-B
231: Move backward over one character.
232: .dk C-N
233: Move down one line, vertically. If you start in the middle of one
234: line, you end in the middle of the next.
235: .dk C-P
236: Move up one line, vertically.
237: .dk "ESC <"
238: Move to the beginning of your text.
239: .dk "ESC >"
240: Move to the end of your text.
241: .ke
242: .es
243: .bs "Erasing Text"
244: .ks 1.5i
245: .dk Rubout
246: Delete the character before the cursor.
247: .dk C-D
248: Delete the character after the cursor.
249: .dk C-K
250: Kill to the end of the line.
251: .ke
252: .lp
253: You already know about the Rubout command which deletes the character
254: before the cursor. Another command, Control-D, deletes the character
255: after the cursor, causing the rest of the text on the line to shift
256: left. If Control-D is typed at the end of a line, that line and the
257: next line are joined together.
258: .lp
259: To erase a larger amount of text, use the Control-K command, which
260: kills a line at a time. If Control-K is done at the beginning or
261: middle of a line, it kills all the text up to the end of the line. If
262: Control-K is done at the end of a line, it joins that line and the
263: next line.
264: .es
265: .bs "Files - Saving Your Work"
266: The commands above are sufficient for creating text in the JOVE
267: buffer. The more advanced JOVE commands just make things easier. But
268: to keep any text permanently you must put it in a \fIfile\fR. Files
269: are the objects which UNIX uses for storing data for a length of
270: time. To tell JOVE to edit text in a file, choose a \fIfilename\fR,
271: such as foo.bar, and type C-X C-R foo.bar<cr>. This \fIreads\fR
272: the file foo.bar so that its contents appear on the screen for
273: editing. You can make changes, and then save the file by typing C-X
274: C-S. This makes the changes permanent and actually changes the file
275: foo.bar. Until then, the changes are only inside you JOVE, and the
276: file foo.bar is not really changed. If the file foo.bar doesn't
277: exist, and you want to create it, read it as if it did exist. When
278: you save your text with C-X C-S the file will be created.
279: .es
280: .es
281: .bs "Giving Numeric Arguments to JOVE Commands"
282: Any JOVE command can be given a \fInumeric argument\fR. Some commands
283: interpret the argument as a repetition count. For example, giving an
284: argument of ten to the C-F command (forward-character) moves forward
285: ten characters. With these commands, no argument is equivalent to an
286: argument of 1.
287: .lp
288: Some commands use the value of the argument, but do something peculiar
289: when there is no argument. For example, ESC G (goto-line) with an
290: argument \fBn\fR goes to the beginning of the \fBn'th\fR line. But
291: ESC G with no argument doesn't do anything.
292: .lp
293: The fundamental way of specifying an argument is to use ESC followed
294: by the digits of the argument. Negative arguments are allowed,
295: although not all of the commands know what to do with one.
296: .lp
297: Typing C-U means do the next command four times. Two such C-U's
298: multiply the next command by sixteen. Thus, C-U C-U C-F moves forward
299: sixteen characters. This is a good way to move forward quickly, since
300: it moves about 1/4 of a line on most terminals. Other useful
301: combinations are: C-U C-U C-N (move down a good fraction of the
302: screen), C-U C-U C-O (make "a lot" of blank lines), and C-U C-K (kill
303: four lines).
304: .lp
305: There are other, terminal-dependent ways of specifying arguments.
306: They have the same effect but may be easier to type. If your terminal
307: has a numeric keypad which sends something recognizably different from
308: the ordinary digits, it is possible to program JOVE to to allow use of
309: the numeric keypad for specifying arguments.
310: .es
311: .bs "The Mark and the Region"
312: In general, a command that processes an arbitray part of the buffer
313: must know where to start and where to stop. In JOVE, such commands
314: usually operate on the text between point and \fIthe mark\fR. This
315: range of text is called \fIthe region\fR. To specify a region, you
316: set point to one end of it and mark at the other. It doesn't matter
317: which one is set first \fIchronologically\fR, or which one comes
318: earlier in the text.
319: .ks 1.5i
320: .dk "C-@"
321: Set the mark where point is.
322: .dk "C-X C-X"
323: Interchange mark and point.
324: .ke
325: .lp
326: For example, if you wish to convert part of the buffer to all
327: upper-case, you can use the C-X C-U command, which operates on the
328: text in the region. You can first go to the beginning of the text to
329: be capitalized, put the mark there, move to the end, and then type C-X
330: C-U. Or, you can set the mark at the end of the text, move to the
331: beginning, and then type C-X C-U. C-X C-U runs the function
332: \fIcase-region-upper\fR, whose name signifies that the region, or
333: everything between point and mark, is to be capitalized.
334: .lp
335: The way to set the mark is with the C-@ command or the C-Space
336: command. They set the mark where point is. Then you can move point
337: away, leaving mark behind.
338: .lp
339: Since terminals have only one cursor, there is no way for JOVE to show
340: you where the mark is located. You have to remember. The usual
341: solution to this problem is to set the mark and then use it soon,
342: before you forget where it is. But you can see where the mark is with
343: the command C-X C-X which puts the mark where point was and point
344: where mark was. The extent of the region is unchanged, but the cursor
345: and point are now at the previous location of the mark.
346: .bs "The Ring of Marks"
347: Aside from delimiting the region, the mark is also useful for
348: remembering a spot that you may want to go back to. To make this
349: feature more useful, JOVE remembers 16 previous locations of the
350: mark. Most commands that set the mark push the old mark onto this
351: stack. To return to a marked location, use C-U C-@. This moves point
352: to where the mark was, and restores the mark from the stack of former
353: marks. So repeated use of this command moves point to all of the old
354: marks on the stack, one by one. Since the stack is actually a ring,
355: enough uses of C-U C-@ bring point back to where it was originally.
356: .lp
357: Some commands whose primary purpose is to move point a great distance
358: take advantage of the stack of marks to give you a way to undo the
359: command. The best example is ESC <, which moves to the beginning of
360: the buffer. If there are more than 22 lines between the beginning of
361: the buffer and point, ESC < sets the mark first, so that you can use
362: C-U C-@ or C-X C-X to go back to where you were. You can change the
363: 22 since it is kept in the variable \fImark-threshold\fR. By setting
364: it to 0, you can make these commands always set the mark. By setting
365: it to a very large number you can prevent these commands from ever
366: setting the mark. If a command desides to set the mark, it prints the
367: message Point Pushed.
368: .es
369: .es
370: .bs "Killing and Moving Text"
371: The most common way of moving or copying text with JOVE is to kill it,
372: and get it back again in one or more places. This is very safe
373: because the last several pieces of killed text are all remembered, and
374: it is versatile, because the many commands for killing syntactic units
375: can also be used for moving those units. There are also other ways of
376: moving text for special purposes.
377: .bs "Deletion and Killing"
378: Most commands which erase text from the buffer save it so that you can
379: get it back if you change your mind, or move or copy it to other parts
380: of the buffer. These commands are known as \fIkill\fR commands. The
381: rest of the commands that erase text do not save it; they are known as
382: \fIdelete\fR commands. The delete commands include C-D and Rubout,
383: which delete only one character at a time, and those commands that
384: delete only spaces or line separators. Commands that can destroy
385: significant amounts of nontrivial data generally kill. The commands'
386: names and individual descriptions use the words "kill" and "delete" to
387: say which they do.
388: .ks 1.8i
389: .dk C-D
390: Delete next character.
391: .dk Rubout
392: Delete previous character.
393: .dk "ESC \\\\"
394: Delete spaces and tabs around point.
395: .dk "C-X C-O"
396: Delete blank lines around the current line.
397: .dk "C-K"
398: Kill rest of line or one or more lines.
399: .dk "C-W"
400: Kill region (from point to the mark).
401: .dk "ESC D"
402: Kill word.
403: .dk "ESC Rubout"
404: Kill word backwards.
405: .dk "ESC K"
406: Kill to end of sentence.
407: .ke
408: .bs "Deletion"
409: The most basic delete commands are C-D and Rubout. C-D deletes the
410: character after the cursor, the one the cursor is "on top of" or
411: "underneath". The cursor doesn't move. Rubout deletes the character
412: before the cursor, and moves the cursor back. Line separators act
413: like normal characters when deleted. Actually, C-D and Rubout aren't
414: always delete commands; if you give an argument, they kill instead.
415: This prevents you from losing a great deal of text by typing a large
416: argument to a C-D or Rubout.
417: .lp
418: The other delete commands are those which delete only formatting
419: characters: spaces, tabs, and line separators. ESC \\ (delete white
420: space) deletes all the spaces and tab characters before and after
421: point. C-X C-O (delete blank lines) deletes all blank lines after the
422: current line, and if the current line is blank deletes all the blank
423: lines preceding the current line as well (leaving one blank line, the
424: current line).
425: .es
426: .bs "Killing by Lines"
427: The simplest kill command is the C-K command. If issued at the
428: beginning of a line, it kills all the text on the line, leaving it
429: blank. If given on a blank line, the blank line disappears. As a
430: consequence, if you go to the front of a non-blank line and type two
431: C-K's, the line disappears completely.
432: .lp
433: More generally, C-K kills from point up to the end of the line, unless
434: it is at the end of a line. In that case, it kills the line separator
435: following the line, thus merging the next line into the current one.
436: Invisible spaces and tabs at the end of the line are ignored when
437: deciding which case applies, so if point appears to be at the end of the
438: line, you can be sure the line separator will be killed.
439: .lp
440: C-K with an argument of zero kills all the text before point on the
441: current line.
442: .es
443: .bs "Other Kill Commands"
444: A kill command which is very general is C-W (kill-region), which kills
445: everything between point and the mark. With this command, you can
446: kill and contiguous characters, if you first set the mark at one end
447: of them and go to the other end.
448: .lp
449: Other syntactic units can be killed: words, with ESC Rubout and ESC D;
450: sentences, with ESC K.
451: .es
452: .es
453: .bs "Un-killing"
454: Un-killing is getting back text which was killed. The usual way to
455: move or copy text is to kill it and then un-kill it one or more times.
456: .ks 1.5i
457: .dk C-Y
458: Yank (re-insert) last killed text.
459: .dk "ESC Y"
460: Replace re-inserted killed text with the previously killed text.
461: .dk "ESC W"
462: Save region as last killed text without killing.
463: .ke
464: .lp
465: Killed text is pushed onto a \fIring buffer\fR called the \fIkill
466: ring\fR that remembers the last 10 blocks of text that were killed.
467: (Why it is called a ring buffer will be explained below.) The command
468: C-Y (yank) reinserts the text of the most recent kill. It leaves the
469: cursor at the end of the text, and puts the mark at the beginning.
470: Thus, a single C-W undoes the C-Y.
471: .lp
472: If you wish to copy a block of text, you might want to use ESC W
473: (copy-region), which copies the region into the kill ring without
474: removing it from the buffer. This is approximately equivalent to C-W
475: followed by C-Y, except that ESC W does not mark the buffer as
476: "changed" and does not temporarily change the screen.
477: .lp
478: There is only one kill ring, and switching buffers or files has no
479: effect on it. After visiting a new file, whatever was last killed in
480: the previous file is still on top of the kill ring. This is important
481: for moving text between files.
482: .bs "Appending Kills"
483: Normally, each kill command pushes a new block onto the kill ring.
484: However, two or more kill commands in a row combine their text into a
485: single entry on the ring, so that a single C-Y command gets it all
486: back as it was before it was killed. This means that you don't have
487: to kill all the text in one command; you can keep killing line after
488: line, or word after word, until you have killed it all, and you can
489: still get it all back at once. (Thus we join television in leading
490: people to kill thoughtlessly.)
491: .fe
492: .lp
493: Commands that kill forward from point add onto the end of the previous
494: killed text. Commands that kill backward from point add onto the
495: beginning. This way, any sequence of mixed forward and backward kill
496: commands puts all the killed text into one entry without rearrangement.
497: .es
498: .bs "Un-killing Earlier Kills"
499: To recover killed text that is no longer the most recent kill, you
500: need the ESC Y (yank-pop) command. The ESC Y command should be used
501: only after a C-Y command or another ESC Y. It takes the un-killed
502: text inserted by the C-Y and replaces it with the text from an earlier
503: kill. So, to recover the text of the next-to-the-last kill, you first
504: use C-Y to recover the last kill, and then use ESC Y to move back to
505: the previous kill.
506: .lp
507: You can think of all the last few kills as living on a ring. After a
508: C-Y command, the text at the front of the ring is also present in the
509: buffer. ESC Y "rotates" the ring bringing the previous string of text
510: to the front, and this text replaces the other text in the buffer as
511: well. Enough ESC Y commands can rotate any part of the ring to the
512: front, so you can get at any kiled text solong as it is recent enough
513: to be still in the ring. Eventually the ring rotates all the way
514: around and the most recent killed text comes to the front (and into
515: the buffer) again. ESC Y with a negative argument rotates the ring
516: backwards.
517: .lp
518: When the text you are looking for is brought into the buffer, you can
519: stop doing ESC Y's and it will stay there. It's really just a copy of
520: what's in at the front of the ring, so editing it does not change
521: what's in the ring. And the ring, once rotated, stays rotated, so
522: that doing another C-Y gets another copy of what you rotated to the
523: fron with ESC Y.
524: .lp
525: If you change you mind about un-killing, and C-W gets rid of the
526: un-killed text at any point, after any number of ESC Y's. C-W pushes
527: the text onto the ring again.
528: .es
529: .es
530: .es
531: .bs "Searching"
532: The search commands are useful for finding and moving to arbitrary
533: positions in the buffer in one swift motion. For example, if you just
534: ran the spell program on a paper and you want to correct some word,
535: you can use the search commands to move directly to that word.
536: .bs "Conventional Search"
537: .ks 1.5i
538: .dk "C-S"
539: Search forward.
540: .dk "C-R"
541: Search backward.
542: .ke
543: .lp
544: To search for the string "FOO" you type "C-S FOO<CR>". If JOVE finds
545: FOO it moves point to the end of it; otherwise JOVE prints an error
546: message and leaves point unchanged. C-S searches forward from point
547: so only occurrences of FOO after point are found. To search in the
548: other direction use C-R. It is exactly the same as C-S except it
549: searches in the opposite direction, and if it finds the string, it
550: leaves point at the beginning of it, not at the end as in C-S.
551: .lp
552: While JOVE is searching it prints the search string on the message
553: line line. This is so you know what JOVE is doing. When the system
554: is heavily loaded, when editing in exceptionally large buffers,
555: searches can take several (sometimes many) seconds.
556: .lp
557: JOVE remembers the last search string you used, so if you want to
558: search for the same string you can type "C-S <cr>". If you mistyped
559: the last search string, you can type C-S followed by C-R. C-R, as
560: usual inserts the default search string into the minibuffer, and then
561: you can fix it up.
562: .es
563: .bs "Incremental Search"
564: This search command is unusual in that is is \fIincremental\fR; it
565: begins to search before you have finished typing the search string.
566: As you type in the search string, JOVE shows you where it would be
567: found. WHen you have typed enough characters to identify the place
568: you want, you can stop. Depending on what you will do next, you may
569: or may not need to terminate the search explicitly with a Return
570: first.
571: .lp
572: The command to search is C-S (i-search-forward).
573: .fb
574: It is assumed that your JOVE has i-search-forward bound to C-S and
575: i-search-reverse bound to C-R. These are not the default bindings.
576: .fe
577: C-S reads in characters and positions the cursor at the first
578: occurrence of the characters that you have typed. If you type C-S and
579: then F, the cursor moves right after the first "F". Type an "O", and
580: see the cursor move to after the first "FO". After another "O", the
581: cursor is after the first "FOO" after the place where you started the
582: search. At the same time, the "FOO" has echoed on the message line.
583: .lp
584: If you type a mistaken character, you can rub it out. After the FOO,
585: typing a Rubout makes the "O" disappear from the message line, leaving
586: only "FO". The cursor moves back to the "FO". Rubbing out the "O"
587: and "F" moves the cursor back to where you started the search.
588: .lp
589: When you are satisfied with the place you have reached, you can type a
590: Return, which stops searching, leaving the cursor where the search
591: brought it. Also, any command not specially meaningful in searches
592: stops the searching and is then executed. Thus, typing C-A would exit
593: the search and then move to the beginning of the line. Return is
594: necessary only of the next character you want to type is a printing
595: character, Rubout, Return, or another search command, since those ar
596: ethe characters that have special meanings inside the search.
597: .lp
598: Sometimes you search for "FOO" and find it, but not the one you
599: expected to find. There was a second FOO that you forgot about,
600: before the one you were looking for. Then type another C-S and the
601: cursor will find the next FOO. This can be done any number of times.
602: If you overshoot, you can rub out the C-S's.
603: .lp
604: After you exist a search, you can search for the same string again by
605: typing just C-S C-S: one C-S command to start the search and then
606: another C-S to mean "search again".
607: .lp
608: If your string is not found at all, the message line says "Failing
609: I-search". The cursor is after the place where JOVE found as much of
610: your string as it could. Thus, if you search for FOOT, and there is
611: not FOOT, you might see the cursor after the FOO in FOOL. At this
612: point there are several things you can do. If your string was
613: mistyped, you can rub some of it out and correct it. If you like the
614: places you have found, you can type Return or some other JOVE command
615: to "accept what the search offered". Or you can type C-G, which
616: undoes the search altogether and positions you back where you started
617: the search.
618: .lp
619: You can also type C-R at any time to start searching backwards. If a
620: search fails because the place you started was too late in the file,
621: you should do this. Repeated C-R's keep looking formore occurrences
622: backwards. A C-S starts going forwards again. C-R's can be rubbed
623: out just like anything else. If you know that you want to start
624: search backwards, you can use C-R (i-search-reverse) to search
625: backward.
626: .es
627: .bs "Regular Expressions Search Strings"
628: I couldn't describe them if I tried!
629: .es
630: .es
631: .bs "Commands for English Text"
632: .bs "Word Commands"
633: JOVE has commands for moving over or operating on words. By
634: convention, they are all ESC commands.
635: .ks 1.7i
636: .dk "ESC F"
637: Move Forward over a word.
638: .dk "ESC B"
639: Move Backward over a word.
640: .dk "ESC D"
641: Kill up to the end of a word.
642: .dk "ESC Rubout"
643: Kill up to the beginning of a word.
644: .dk "ESC T"
645: Transpose two words; drag a word forward or backward across other words.
646: .ke
647: .lp
648: Notice how these commands form a group that parallels the character
649: base commands, C-F, C-B, C-D, Rubout, and C-T.
650: .lp
651: The commands ESC F and ESC B move forward and backward over words.
652: They are thus analogous to Control-F and Control-B, which move over
653: single characters. Like their Control- analogues, ESC F and ESC B
654: move several words if given an argument. ESC F with a negative
655: argument moves backward like ESC B, and ESC B with a negative argument
656: moves forward. Forward motion stops right after the last letter of
657: the word, while backward motion stops right before the first letter.
658: .lp
659: It is easy to kill a word at a time. ESC D kills the word after
660: point. To be precise, it kills everything from point to the place ESC
661: F would move to. Thus, if point is in the middle of a word, only the
662: part after point is killed. If some punctuation comes after point,
663: and before the next word, it is killed along with the word. If you
664: wish to kill only the next word but not the punctuation, simply do ESC
665: F to get to the end, and kill the word backwards with ESC Rubout. ESC
666: D takes arguments just like ESC F.
667: .lp
668: ESC Rubout kills the word before point. It kills everything from
669: point back to where ESC B would move to. If point is after the space
670: int "FOO, BAR", then "FOO, " is killed. If you wish to kill just
671: "FOO", then do a ESC B and a ESC D instead of a ESC Rubout.
672: .es
673: .bs "Sentence and Paragraph Commands"
674: The JOVE commands for manipulating sentences and paragraphs are
675: entirely ESC commands, so as to resemble the word-handling commands.
676: .ks 1.7i
677: .dk "ESC A"
678: Move back to the beginning of the sentence.
679: .dk "ESC E"
680: Move forward to the end of the sentence.
681: .dk "ESC K"
682: Kill forward to the end of the sentence."
683: .dk "ESC ["
684: Move back to previous paragraph beginning.
685: .dk "ESC ]"
686: Move forward to next paragraph end.
687: .dk "C-X Rubout"
688: Kill back to the beginning of the sentence.
689: .ke
690: .bs Sentences
691: The commands ESC A and ESC E move to the beginning and end of the
692: current sentence, respectively. They were chosen to resemble
693: Control-A and Control-E, which move to the beginning and end of a
694: line. Unlike them, ESC A and ESC E if repeated or given numeric
695: arguments move over successive sentences. JOVE considers a sentence
696: to end wherever there is a ".", "?", or "!" followed by the end of a
697: line, or one or more spaces. Neither ESC A nor ESC E moves past the
698: end of the line or spaces which delimit the sentence.
699: .lp
700: Just as C-A and C-E have a kill command, C-K, to go with them, so ESC
701: A and ESC E have a corrisponding kill command ESC K which kills from
702: point to the end of the sentence. With minus one as an argument it
703: kills back to the beginning of the sentence. Larger arguments serve
704: as a repeat count.
705: .lp
706: There is a special command, C-X Rubout for killing back to the
707: beginning of a sentence, because this is useful when you change your
708: mind in the middle of composing text.
709: .es
710: .bs Paragraphs
711: ESC [ moves to the beginning of the current or previous paragraph,
712: while ESC ] moves to the end of the current or next paragraph. Blank
713: lines and text justifier command lines separate paragraphs and are not
714: part of any paragraph. Also, an indented line starts a new
715: paragraph. A line beginning with a letter which can't be part of a
716: word, e.g., period, singlequote, "-", "\\", it is considered a
717: paragraph terminator.
718: .es
719: .es
720: .bs Indentation Commands for Text
721: .ks 1.7i
722: .dk "Tab"
723: Indent "appropriately" in a mode-dependent fashion.
724: .dk "LineFeed"
725: Is the same as Return, except it copies the indent of the line you
726: just left.
727: .dk "ESC M"
728: Moves to the line's first non-blank character.
729: .ke
730: .lp
731: The way to request indentation is with the Tab command. Its precise
732: effect depends on the major mode. In Text mode, it indents to the
733: next tab stop. In C mode, it indents to the "right" position for C
734: programs.
735: .lp
736: To move over the indentation on a line, do ESC M. This command, given
737: anywhere on a line, positions the cursor at the first nonblank
738: character on the line.
739: .es
740: .bs "Text Filling"
741: auto-fill mode lets you type in text that is \fIfilled\fR (broken up
742: into lines that fit ina specified width) as you go. If you alter
743: existing text and this cause it to cease to be properly filled, JOVE
744: can fill it again if you ask.
745: .lp
746: Entering auto-fill mode is done with ESC X auto-fill. From then on,
747: lines are broken automatically at spaces when they get longer than the
748: desired width. To leave auto-fill mode, execute ESC X auto-fill
749: again. When auto-fill mode is in effect, the word "Fill" appears in
750: the mode line.
751: .lp
752: If you edit the middle of a paragraph, it may no longer correctly be
753: filled. To refill a paragraph, use the command ESC J. It causes the
754: paragraph that point is inside to be filled. All the line breaks are
755: removed and then new ones are inserted where necessary.
756: .lp
757: The maximum line width for filling is in the variable right-margin.
758: Both ESC J and auto-fill make sure that no line exceeds this width.
759: right-margin is initially 72.
760: .es
761: .bs "Case Conversion Commands"
762: .ks 1.5i
763: .dk "ESC L"
764: Convert following word to lower case.
765: .dk "ESC U"
766: Convert following word to upper case.
767: .dk "ESC C"
768: Capitalize the following word.
769: .ke
770: .lp
771: The word conversion commands are most useful. ESC L converts the word
772: after point to lower case, moving past it. This, successive ESC L's
773: convert successive words. ESC U converts to all capitals instead,
774: while ESC C puts the first letter of the word into upper case and the
775: rest into lower case. All these commands convert several words at
776: once if given an argument. They are especially convenient for
777: converting a large amount of text from all upper case to mixed case,
778: because you can move through the test using ESC L, ESC U or ESC C on
779: each word as appropriate.
780: .lp
781: When given a negative argument, the word case conversion commands
782: apply to the appropriate number of words before point, but do not move
783: point. This is convenient when you have just typed a word in the
784: wrong case. You can give the case conversion command and continue
785: typing.
786: .lp
787: If a word case conversion command is given in the middle of a word, it
788: applies only to the part of the word which follows the cursor,
789: treating it as a whole word.
790: .lp
791: The other case conversion functions are case-region-upper and
792: case-region-lower, which convert everything between point and mark to
793: the specified case. Point and mark do not move.
794: .es
795: .es
796: .bs "Commands for Fixing Typos"
797: In this section we describe the commands that are especially useful
798: for the times when you catch a mistake on your text after you have
799: made it, or change your mind while composing text on line.
800: .ks 2.2i
801: .dk "Rubout"
802: Delete last character.
803: .dk "ESC Rubout"
804: Kill last word.
805: .dk "C-X Rubout"
806: Kill to beginning of sentence.
807: .dk "C-T"
808: Transpose two characters.
809: .dk "C-X C-T"
810: Transpose two lines.
811: .dk "ESC Minus ESC L"
812: Convert last word to lower case.
813: .dk "ESC Minus ESC U"
814: Convert last word to upper case.
815: .dk "ESC Minus ESC C"
816: Convert last word to lower case with capital initial.
817: .ke
818: .bs "Killing Your Mistakes"
819: The Rubout command is the most important correction command. When
820: used among printing (self-inserting) characters, it can be thought of
821: as canceling the last character typed.
822: .lp
823: When your mistake is longer than a couple of characters, it might be
824: more convenient to use ESC Rubout or C-X Rubout. ESC Rubout kills
825: back to the start of the last word, and C-X Rubout kills back to the
826: start of the last sentence. C-X Rubout is particularly useful when
827: you are thinking of what to write as you type it, in case you change
828: your mind about phrasing. ESC Rubout and C-X Rubout save the killed
829: text for C-Y and ESC Y to retrieve.
830: .lp
831: ESC Rubout is often useful even when you have typed only a few
832: characters wrong, if you know you are confused in your typing and
833: aren't sure what you typed. At such a time, you cannot correct with
834: Rubout except by looking at the screen to see what you did. It
835: requires less thought to kill the whole word and start over again,
836: especially if the system is heavily loaded.
837: .es
838: .bs "Transposition"
839: The command error of transposing two characters can be fixed, when
840: they are adjacent, with the C-T command. Normally, C-T transposes the
841: two characters on either side of the cursor. When given at the end of
842: a line, rather than switching the last character of the line with the
843: line separator, which would be useless, C-T transposees the last two
844: characters on the line. So, if you catch your transposition error
845: right away, you can fix it with just a C-T. If you don't catch it so
846: fast, you must move the cursor back to between the two characters.
847: .lp
848: To transpose two lines, use the C-X C-T command.
849: .es
850: .bs "Checking and Correcting Spelling"
851: When you write a paper, you should correct its spelling at some point
852: close the finishing it. To correct the entire buffer, do ESC X
853: spell-buffer. This invokes the UNIX spell program, which prints a list
854: of all the misspelled words. JOVE catches the list and places it in a
855: JOVE buffer called Spell, and then looks up each misspelled word and
856: remembers where it is in the buffer being corrected. Then you can go
857: forward to each misspelled word with C-X C-N (next-error) and backward
858: with C-X C-P (previous-error). See error parsing.
859: .es
860: .es
861: .bs "File Handling"
862: The basic unit of stored data is the file. Each program, each paper,
863: lives usually in its own file. To edit a program or paper, the editor
864: must be told the name of the file that contains it. This is called
865: \fIvisiting\fR a file. To make your changes to the file perminent on
866: disk, you must \fIsave\fR the file.
867: .bs "Visiting Files"
868: .ks 1.5i
869: .dk "C-X C-V"
870: Visit a file.
871: .dk "C-X C-R"
872: Same as C-X C-V.
873: .dk "C-X C-S"
874: Save the visited file.
875: .dk "ESC ~"
876: Tell JOVE to forget that the buffer has been changed.
877: .ke
878: .lp
879: \fIVisiting\fR a file means copying its contents into JOVE where you
880: can edit them. JOVE remembers the name of the file you visited.
881: Unless you use the multiple buffer or window features of JOVE, you can
882: only be visiting one file at a time. The name of the current selected
883: buffer is visible in the mode line.
884: .lp
885: The changes you make with JOVE are made in a copy inside JOVE. The
886: file itself is not changed. The changed test is not permanent until
887: you \fIsave\fR it in a file. The first time you change the text, a
888: star appears at the end of the mode line; this indicates that the text
889: contains fresh changes which will be lost unless you save them.
890: .lp
891: To visit a file, use the command C-X C-V. Follow the command with the
892: name of the file you wish to visit, terminated by a Return. You can
893: abort the command by typing C-G, or edit the filename with the many of
894: the standard JOVE commands (e.g., C-A, C-E, C-F, ESC F, ESC Rubout).
895: If the filename you wish to visit is similar to the filename in the
896: mode line (the default file name), you can type C-R to insert the
897: default and then edit it. If you do type a Return to finish the
898: command, the new file's text appears on the screen, and its name
899: appears in the mode line. In addition, its name becomes the new
900: default filename.
901: .lp
902: If you wish to save the file and make your changes permanent, type C-X
903: C-S. After the save is finished, C-X C-S prints the filename and the
904: number of characters and lines that it wrote to the file. If there
905: are no changes to save (no star at the end of the mode line), the file
906: is not saved; otherwise the changes saved and the star at the end of
907: the mode line will disappear.
908: .lp
909: Because a system crash can cause you to lose everything you have done
910: since the last save, we provide auto-save mode, which saves the files
911: you are visiting at regular intervals automatically. See auto-save.
912: .lp
913: What if you want to create a file? Just visit it. JOVE prints "(New
914: file)" but aside from that behaves as if you had visited an existing
915: empty file. If you make any changes and save them, the file is
916: created. If you visit a nonexistent file unintentionally (because you
917: typed the wrong filename), go ahead and visit the file you meant. If
918: you don't save the unwanted file, it is not created.
919: .lp
920: If you alter one file and then visit another in the same buffer, JOVE
921: offers to save the old one. If you answer YES, the old file is saved;
922: if you answer NO, all the changes you have made to it since the last
923: save are lost. You should not type ahead after a file visiting
924: command, because your type-ahead might answer an unexpected question
925: in a way that you would regret.
926: .lp
927: Sometimes you will change a buffer by accident. Even if you undo the
928: change by hand, JOVE still knows that "the buffer has been changed".
929: You can tell JOVE to belive that there have been no changes with the
930: ESC ~ command. This command simply clears the "modified" flag which
931: says that the buffer contains changes which need to be saved. Even if
932: the buffer really \fIis\fR changed JOVE will still act as if it were
933: not.
934: .lp
935: If JOVE is about to save a file and sees that the date of the version
936: on disk does not match what JOVE last read or wrote, JOVE notifies you
937: of this fact, and asks what to do, because this probably means that
938: something is wrong. For example, somebody else may have been editing
939: the same file. If this is so, there is a good chance that your work
940: or his work will be lost if you don't take the proper steps. You
941: should first find out exactly what is going on. If you determine that
942: somebody else has modified the file, save your file under a different
943: name and then DIFF the two files to merge the two sets of changes.
944: Also get in touch with the other person so that he doesn't continue
945: editing.
946: .es
947: .bs "How to Undo Drastic Changes to a File"
948: If you have made several extensive changes to a file and then change
949: your mind about them, and you haven't yet saved them, you can get rid
950: of them by reading in the previous version of the file. You can do
951: this with the C-X C-V command, to visit the unsaved version of the file.
952: .es
953: .bs "Auto Save Mode"
954: In auto-save mode, JOVE saves your file from time to time (based on
955: counting your commands) without being asked. This prevents you from
956: losing more than a limited amount of work in a disaster.
957: .lp
958: You can turn auto saving on or off in an individual buffer with ESC X
959: auto-save. In addition, you can have auto savng by default in all
960: buffers by putting the auto-save line in your initialization file.
961: See initialization files. The frequency of saving can be specified.
962: .lp
963: Once you have visited a file, you can turn auto saving on or off with
964: ESC X auto-save. Line other minor mode commands, ESC X auto-save
965: toggles. If you start typing a new file into a buffer without
966: visiting anything, auto-save mode is initially off, but you can turn
967: it on with ESC X auto-save.
968: .lp
969: When JOVE decides to do an auto-save, it doesn't save it under the
970: name you have visited; instead it saves it under some special "auto
971: save file name". This file name will be the same as your visited file
972: name except for having "+" appended to it. An error in the process of
973: auto saving prints "(Auto Save Error!)". When you leave the editor
974: normally, all auto saved files are removed. However, if there is an
975: internal error or the system crashes, the save files will not be
976: removed so that you salvage your work.
977: .lp
978: If you want to save your file "for real", use C-X C-S, as always.
979: .es
980: .bs "Miscellaneous File Operations"
981: .lp
982: ESC X write-named-file <file><cr> writes the contents of the buffer
983: into the file <file>, and then visits that file. It can be thought of
984: as a way of "changing the name" of the file you are visiting. Unlike
985: C-X C-S, write-file saves even if the buffer has not been changed.
986: C-X C-W is another way of getting this command.
987: .lp
988: ESC X insert-file <file><cr> inserts the contents of <file> into the
989: buffer at point, leaving point unchanged before the contents. You can
990: also use C-X C-I to get this command.
991: .lp
992: ESC X write-region <file><cr> writes the region (the text between
993: point and mark) to the specified file. It does not set the visited
994: filenames. The buffer is not changed.
995: .lp
996: ESC X append-region <file><cr> appends the region to <file>. The text
997: is added to the end of <file>.
998: .es
999: .es
1000: .bs "Using Multiple Buffers"
1001: When we speak of "the buffer", which contains the text you are
1002: editing, we have given the impression that there is only one. In
1003: fact, there may be many of them, each with its own body of text. At
1004: any time only one buffer can be \fIselected\fR and available for
1005: editing, but it isn't hard to switch to a different one. Each buffer
1006: individually remembers which file it is visiting, what modes are in
1007: effect, and whether there are any changes that need saving.
1008: .ks 1.3i
1009: .dk "C-X B"
1010: Select or create a buffer.
1011: .dk "C-X C-F"
1012: Visit a file in its own buffer.
1013: .dk "C-X C-B"
1014: List the existing buffers.
1015: .dk "C-X K"
1016: Kill a buffer.
1017: .ke
1018: .lp
1019: Each buffer in JOVE has a single name, which normally doesn't change.
1020: A buffer's name can be anylength. The name of the currently selected
1021: buffer, and the name of the file visited in it, are visible in the
1022: mode line when you are at top level. A newly started JOVE has only
1023: one buffer, named "Main".
1024: .bs "Creating and Selecting Buffers"
1025: To create a new buffer, you need only think of a name for it (say,
1026: FOO) and then do C-X B FOO<cr>, which is the command C-X B
1027: (select-buffer) followed by the name. This makes a new, empty buffer
1028: and selects it for editing. The new buffer is not visiting any file,
1029: so if you try to save it you will be asked for the filename to use.
1030: Each buffer as its own major mode; the new buffer's major mode is
1031: always Text mode.
1032: .lp
1033: To return to buffer FOO later after hacing switched to another, the
1034: same command C-X B FOO<cr> is used, since C-X B can atell whether a
1035: buffer named FOO exists already or not. C-X B Main<cr> reselects the
1036: buffer Main that JOVE started out with. Just C-X B<cr> reselects the
1037: previous buffer. Repeated C-X B<cr>'s alternate between the last two
1038: buffers selected.
1039: .lp
1040: You can also read a file into its own newly created buffer, all with
1041: one command: C-X C-F (find-file), followed by the filename. The name
1042: of the buffer is the last name in the element of the file's pathname.
1043: C-F stands for "Find", because if the specified file already resides
1044: in a buffer in your JOVE, that buffer is reselected. So you need not
1045: remember whether you have brought the file in already or not. A
1046: buffer created by C-X C-F can be reslected later with C-X B or C-X
1047: C-F, whichever you find more convenient. Nonexistent files can be
1048: created with C-X C-F just as they can with C-X C-V.
1049: .es
1050: .bs "Using Existing Buffers"
1051: To get a list of all the buffers that exist, do C-X C-B
1052: (list-buffers). Each buffer's type, name, and visited
1053: filenames are printed. A star before the buffer name indicates a
1054: buffer which contains changes that hav enot been saved. The number
1055: that appears at the beginning of a line in a C-X C-B listing is that
1056: buffer's \FIbuffer number\fR. You can select a buffer by typing its
1057: number in place of its name. If a buffer with that number doesn't
1058: already exist, a new buffer is created with that number as its name.
1059: .lp
1060: If several buffers have stars, you should save some of them with C-X
1061: C-M (write-modified-files). This finds all the buffers that need
1062: saving and then saves them. Saving the buffers this way is much
1063: easier and more efficient than selecting each one and typing C-X C-S.
1064: If a numeric argument is supplied, it asks whether to save each buffer,
1065: individually.
1066: .lp
1067: ESC X rename-buffer <new name><cr> changes the name of the currently
1068: selected buffer.
1069: .lp
1070: ESC X erase-buffer<buffer name><cr> erases the contents of the <buffer
1071: name> without deleting the buffer entirely.
1072: .es
1073: .bs "Killing Buffers"
1074: After you use a JOVE for a while, it may fill up with buffers which
1075: you no longer need. Eventually you can reach a point where trying to
1076: create any more results in an "out of memory" or "out of lines"
1077: error. When this happens you will want to kill some buffers with the
1078: C-X K (delete-buffer) command. You can kill the buffer FOO by doing
1079: C-X K FOO<cr>. If you type C-X K <cr> JOVe will kill the previously
1080: selected buffer. If you try to kill a buffer that needs saving JOVE
1081: will ask you to confirm it.
1082: .es
1083: .es
1084: .bs "Controlling the Display"
1085: Since only part of a large file fits on the screen, JOVE tries to show
1086: the part that is likely to be interesting. The display control
1087: commands allow you to see a different part of the file.
1088: .ks 1.5i
1089: .dk "C-L"
1090: Reposition point at a specified vertical position, OR clear and redraw
1091: the screen with point in the same place.
1092: .dk "C-V"
1093: Scroll forwards (a screen or a few lines).
1094: .dk "ESC V"
1095: Scroll backwards.
1096: .dk "C-Z"
1097: Scroll forward some lines.
1098: .dk "ESC Z"
1099: Scroll backwards some lines.
1100: .dk "ESC ,"
1101: Beginning of screen.
1102: .dk "ESC ."
1103: End of screen.
1104: .ke
1105: .lp
1106: The terminal screen is rarely large enough to display all of your
1107: file. If the whole buffer doesn't fit on the screen, JOVE shows a
1108: contiguous portion of it, containing point. It continues to show
1109: approximately the same portion until point moves outside of it; then
1110: JOVE chooses a new portion centered the new point. This is JOVE's
1111: guess as to what you are most interested in seeing. But if the guess
1112: is wrong, you can use the display control commands to see a different
1113: portion. The finite area of screen through which you can see part of
1114: the buffer is called \fIthe window\fR, and the choice of where in the
1115: buffer to start displaying is also called \fIthe window\fR.
1116: .lp
1117: First we describe how JOVE chooses a new window position on its own.
1118: The goal is usually to place point half way down the screen. This is
1119: controlled by the variable scroll-step, whose value is the number of
1120: lines above the bottom or below the top of the window that the line
1121: containing point is placed. A value of 0 (the initial value) means
1122: center the screen.
1123: .lp
1124: The basic display control command is C-L (redraw-display). In its
1125: simplest form, with no argument, it tells JOVE to choose a new window
1126: position, centering point half way from the top as usual.
1127: .lp
1128: C-L with a positive argument chooses a new window so as to point point
1129: that many lines from the top. An argument of zero puts point on the
1130: very top line. Point does not move with respect to the text; rather,
1131: the text and point move rigidly on the screen.
1132: .lp
1133: If point stays on the same line, the screen is first cleared and then
1134: redrawn. Thus, two C-L's in a row are guarenteed to clear the screen.
1135: .lp
1136: The \fIscrolling\fR commands C-V, ESC V, C-Z, and ESC Z, let you move
1137: the whole display up or down a few lines. C-V (next-page) with an
1138: argument shows you that many more lines at the bottom of the screen,
1139: moving the text and point up together as C-L might. C-V with a
1140: negative argument shows you more lines at the top of the screen, as
1141: does ESC V with a positive argument.
1142: .lp
1143: To read the buffer a screenful at a time, use the C-V command with no
1144: argument. It takes the last line at the bottom of the screen and puts
1145: it at the top, followed by nearly a whole screenful of lines not
1146: visible before. Point is put at the top of the screen. Thus, each
1147: C-V shows the "next screenful", except for one line of overlap to
1148: provide continuity. To move backward, use ESC V without an argument,
1149: which moves a whole screenful backwards (again with overlap).
1150: .lp
1151: C-Z and ESC Z scroll one line forward and one line backward,
1152: respectively. These are convenient for moving in units of lines
1153: without having to type a numeric argument.
1154: .lp
1155: Use ESC , to move to the top of the window and ESC . to go to the
1156: end. Notice the similarity between ESC , and ESC <, and ESC . and
1157: ESC >. The only difference between them is how far they move.
1158: .es
1159: .bs "Multiple Windows"
1160: JOVE allows you to split the screen into two or more \fIwindows\fR and
1161: use them to display parts of different files, or different parts of
1162: the same file.
1163: .ks 1.5i
1164: .dk "C-X 2"
1165: Divide the current window into two smaller ones.
1166: .dk "C-X 1"
1167: Delete windows all but the current one.
1168: .dk "C-X N"
1169: Switch to the next window.
1170: .dk "C-X P"
1171: Switch to the previous window.
1172: .dk "C-X O"
1173: Same as C-X P.
1174: .dk "C-X ^"
1175: Make this window bigger.
1176: .dk "ESC C-V"
1177: Scroll the other window.
1178: .ke
1179: .lp
1180: When using \fImultiple window\fR mode, the text portion of the screen
1181: is divided into separate parts called \fIwindows\fR, which display
1182: different pieces of text. Each window can display different files, or
1183: parts of the same file. Only one of the windows is selected; that is
1184: the window which the cursor is in. Editing normally takes place in
1185: that window alone. To edit in another window, you would give a
1186: special command to move the cursor to the other window, and then edit
1187: there.
1188: .lp
1189: Each window displays a mode line for the buffer it's displaying. This
1190: is useful when we are editing different files and want to know which
1191: file the other window is displaying. In addition, all except the bottom
1192: window put dashes at the beginning and end of the mode line so that
1193: there is a clear seperator between windows.
1194: .lp
1195: The command C-X 2 (split-current-window) enters multiple window mode.
1196: A new mode line appears accross the middle of the screen, dividing the
1197: text display area into two halves. Both windows contain the same
1198: buffer and display the same position in it, namely where point was at
1199: the time you issued the command. The cursor moves to the second
1200: window.
1201: .lp
1202: To return to viewing only one window, use the command C-X 1
1203: (delete-other-windows). The current window expands to fill the whole
1204: screen, and the other windows disappear until the next C-X 2.
1205: .lp
1206: While there is more than one window, you can use C-X N (next-window)
1207: to switch to the next window, and C-X P (previous-window) to switch to
1208: the previous one. If you are in the bottom window and you type C-X N,
1209: you will be placed in the top window, and the same kind of thing
1210: happens when you type C-X P in the top window, namely you will be
1211: placed in the bottom window. C-X O is the same as C-X P. It stands
1212: for other window because when there are only two windows, repeated use
1213: of this command with switch between the two windows.
1214: .lp
1215: Often you will be editing one window while using the other just for
1216: reference. Then, the command ESC C-V (page-next-window) is very
1217: useful. It scrolls the next window, as if you switched to the next
1218: window, typed C-V, and switched back, without your having to do all
1219: that. With a negative argument, ESC C-V will do an ESC V in the next
1220: window.
1221: .lp
1222: When a window splits, both halves are approximately the same size.
1223: You can redistribute the screen space between the windows with the C-X
1224: ^ (grow-window) command. It makes the currently selected window grow
1225: one line bigger, or as many lines as is specified with a numeric
1226: argument. Use ESC X shrink-window to make the current window smaller.
1227: .bs Multiple Windows and Mulitple Buffers
1228: Buffers can be selected independently in each window. The C-X B
1229: command selects a new buffer in whichever window the cursor is in.
1230: The other window's buffer does not change.
1231: .lp
1232: You can view the same buffer in more than one window. Although the
1233: same buffer appears in both windows, they have different values of
1234: point, so you can move around in one window while the other window
1235: continues to show the same text. Then, having found the place you
1236: wish to refer to, you can go back into the other window with C-X O to
1237: make your changes.
1238: .lp
1239: If you have the same buffer in both windows, you must beware of trying
1240: to visit a different file in one of the windows with C-X C-V, because
1241: if you bring a new file into this buffer, it will replaced the old
1242: file in \fIboth\fR windows. To view different files in differnent
1243: windows, you must switch buffers in one of the windows first (with C-X
1244: B or C-X C-F, perhaps).
1245: .lp
1246: A convenient "combination" command for viewing something in another
1247: window is C-X 4 (visit-in-other-window). With this command you can
1248: ask to see any specified buffer, file or tag in the other window.
1249: Follow the C-X 4 with either B and a buffer name, F and a file name,
1250: or T and a tag name. This switches to the other window and finds
1251: there what you specified. If you were previously in one-window mode,
1252: multiple-window mode is entered. C-X 4 B is similar to C-X 2 C-X B.
1253: C-X 4 F is similar to C-X 2 C-X C-F. C-X 4 T is similar to C-X 2 C-X
1254: T. The difference is one of efficiency, and also that C-X 4 works
1255: equally as well if you are already using two windows.
1256: .es
1257: .es
1258: .bs "Replacement Commands"
1259: Global search-and-replace operations are not needed as often in JOVE
1260: as they are in other editors, but they are available. In addition to
1261: the simple Replace operation which is like that found in most editors,
1262: there is a Query Replace operation which asks you, for each occurrence
1263: of the pattern, whether to replace it.
1264: .lp
1265: To replace every occurrence of FOO after point which BAR, you can do
1266: .eg "ESC R FOO<cr>BAR"
1267: Replacement occurs only after point, so if you want to cover the whole
1268: buffer you must go to the beginning first. Replacement continues to
1269: the end of the buffer.
1270: .bs "Query Replace"
1271: If you want to change only some of the occurrences of FOO, not all,
1272: then you cannot use and ordinary Replace. Instead, use
1273: .eg "ESC Q FOO<cr>BAR"
1274: This displays each occurrence of FOO and waits for you to say whether
1275: to replace it with a BAR. The things you can type when you are shown
1276: an occurrence of FOO are:
1277: .ks 1.3i
1278: .dk "Space"
1279: to replace the FOO.
1280: .dk "Rubout"
1281: to skip the next FOO without replacing this one.
1282: .dk "Return"
1283: to exit without doing any more replacements.
1284: .dk "Period"
1285: to replace this FOO and then exit.
1286: .dk "! or P"
1287: to replace all remaining FOO's without asking.
1288: .dk "C-R or R"
1289: to enter a recursive editing level, in case the FOO needs to be edited
1290: rather than just replaced with a BAR. When you are done, exit the
1291: recursive editing level with C-X C-C and the next FOO will be
1292: displayed.
1293: .dk "C-W"
1294: to delete the FOO, and then start editing the buffer. When you are
1295: finished editing whatever is to replace the FOO, exit the recursive
1296: editing level with C-X C-C and the next FOO will be displayed.
1297: .dk "U"
1298: move to the last replacement and undo it, and then enter a recursive
1299: editing level. When you have finished editing the FOO, exit the
1300: recursive editing level with C-X C-C and then next FOO will be
1301: displayed.
1302: .ke
1303: .es
1304: .es
1305: .bs "Processes Under JOVE"
1306: Another feature in JOVE is its ability to interact with UNIX in a
1307: useful way. You can run other UNIX commands from JOVE and catch their
1308: output in JOVE buffers. In this chapter we will discuss the different
1309: ways to run and interact with UNIX commands.
1310: .bs Non-interactive UNIX commands
1311: To run a UNIX command from JOVE just type "C-X !" followed by the name
1312: of the command terminated with Return. For example, to get a list of
1313: all the users on the system, you do:
1314: .eg "C-X ! who<cr>"
1315: Then JOVE picks a reasonable buffer in which the output from the
1316: command will be placed. E.g., "who" uses the buffer called "who", and
1317: "ps alx" uses "ps", and "fgrep -n foo *.c" uses "fgrep". If JOVE
1318: wants to use a buffer that already exists it first erases the old
1319: contents. If the buffer it selects holds a file, not output from a
1320: previous shell command, you must first delete that buffer with C-X K.
1321: .lp
1322: Once JOVE has picked a buffer it puts that buffer in a window so you
1323: can see the command's output as it is running. If there is only one
1324: window JOVE will automatically make another one. Otherwise, JOVE
1325: tries to pick the most convenient one window which isn't the current
1326: one.
1327: .lp
1328: It's not a good idea to type anything while the command is running.
1329: There are two reasons for this:
1330: .ks 1i
1331: .dk "(1)"
1332: JOVE won't see the characters (thus won't execute them) until the
1333: command finishes, so you may forget what you've typed.
1334: .dk "(2)"
1335: Although JOVE won't know what you've typed, it WILL know that you've
1336: typed something, and then it will try to be "smart" and not update the
1337: display until it's interpreted your what you've typed. But, of
1338: course, JOVE won't interpret what you type until the UNIX command
1339: completes, so you're left with the uneasy feeling you get when you
1340: don't know what the hell the computer is doing.
1341: .fb
1342: This is a bug and should be fixed, but probably won't be for a while.
1343: .fe
1344: .ke
1345: .lp
1346: If you want to interrupt the command for some reason (perhaps you
1347: mistyped it,or you changed your mind) you can type C-]. Typing this
1348: inside JOVE while a process is running is the same as type C-C when
1349: you are outside JOVE, namely the process stops in a hurry.
1350: .lp
1351: When the command finishes JOVE puts you back in the window you started
1352: in. Then it prints a message indicating whether or not the command
1353: completed successfully in its (the command's) opinion. That is, if
1354: the command had what it considers and error, JOVE will print an
1355: appropriate message. Interrupting a command with C-] is considered an
1356: error.
1357: .bs "Limitations of Non-Interactive Processes"
1358: The reason these are called non-interactive processes is that you
1359: can't type any input to them; you can't interact with them; they can't
1360: ask you questions because there is no way for you to answer. For
1361: example, you can't run a command interpreter (a shell) with C-X !
1362: because there is no way to type it a command. Remember that JOVE is
1363: listening to your keyboard, not the process in the window, and JOVE
1364: doesn't see what you type until the process dies.
1365: .lp
1366: C-X ! is useful for running commands that do some output and then
1367: exit. For example, it's very useful to use with the C compiler to
1368: catch compilation error messages (see Compiling C Programs), or with
1369: the "grep" commands.
1370: .es
1371: .es
1372: .bs "Interactive Processes -- Run a Shell in a Window"
1373: Some versions of JOVE have the capability of running interative
1374: processes. This is more useful than non-interactive processes for
1375: certain types of jobs:
1376: .ks
1377: .dk "(1)"
1378: You can go off and do some editing while the command is running. This
1379: is useful for commands that do sporadic output and run for fairly long
1380: periods of time.
1381: .dk "(2)"
1382: Unlike non-interactive processes, you can type input to this type. In
1383: addition, you can edit what you type with the power of all the JOVE
1384: commands \fBbefore\fR you send the input to the process. This is a
1385: really important feature, and is especially useful for running a shell
1386: in a window.
1387: .dk "(3)"
1388: Because you can continue with normal editing while one of the
1389: processes is running, you can create a bunch of contexts and manage
1390: them (select them, delete them, or temporarily put them aside) with
1391: JOVE's window and buffer mechanisms.
1392: .ke
1393: .lp
1394: Although we've created an image of processes being attached to
1395: windows, in fact they are attached to buffers. Therefore, once an
1396: i-process is running you can select another buffer into that window,
1397: or if you wish you can delete the window altogether. If you reselect
1398: that buffer later it will be up to date. That is, even though the
1399: buffer wasn't visible it was still receiving output from the process.
1400: You don't have to worry about missing anything when the buffer isn't
1401: visible.
1402: .bs Advantages of Running Processes in JOVE Windows.
1403: There are several advantages to running a shell in a window. What you
1404: type isn't seen immediately by the process ; instead JOVE waits until
1405: you type an entire line before passing it on to the process to read.
1406: This means that before you type Return, all JOVE's editing
1407: capabilities are available for fixing typos on your input line. If
1408: you discover an error at the beginning of the line, rather than
1409: erasing it and starting over, you can simply move to the error,
1410: correct it, move back and continue typing.
1411: .lp
1412: Another feature is that you have the entire history of your session is
1413: a JOVE buffer. You don't have to worry about output from a command
1414: moving past the top of the screen. if you missed some output you can
1415: move back through it with ESC V and other command. In addition, you
1416: can save yourself retyping a command (or a similar one) by sending
1417: edited versions of previous ones.
1418: .es
1419: .bs "Differences between Normal and I-process Buffers"
1420: JOVE behaves differently in several ways when you are in an I-process
1421: buffer. The most obvious one is that Return does different things
1422: depending on both your position in the buffer and on the state of the
1423: process. In the normal case, when point is at the end of the buffer,
1424: Return does what you'd expect: it inserts a line-separator and then
1425: sends the line to the process. If you are somewhere else in the
1426: buffer, possibly positioned at a previous command that you want to
1427: edit, Return will place a copy of that line (with the prompt discarded
1428: if there is one) at the end of the buffer and move you there. Then
1429: you can edit the line and type Return as in the normal case. If the
1430: process has died for some reason, Return does nothing. It doesn't
1431: even insert itself. If that happens unexpectedly, you should type ESC
1432: X list-processes<cr> to get a list of each process and its state. If
1433: your process died abnormally, list-processes may help you figure out
1434: why.
1435: .es
1436: .bs "How to Run a Shell in a Window"
1437: Type ESC X i-shell<cr> to start up a shell. As with C-X !, JOVE will
1438: create a buffer, called \fBshell.1\fR, and select a window for this
1439: new buffer. But unlike C-X ! you will be left in the new window. Now,
1440: the shell process is said to be attached to shell.1, and it is
1441: considered an I-process buffer.
1442: .lp
1443: Needs work.
1444: .es
1445: .es
1446: .es
1447:
1448: .bs "Editing C Programs"
1449: .bs "Compiling Your Program"
1450: .es
1451: .bs "Indentation Commands"
1452: .es
1453: .bs "Parenthesis and Brace Matching"
1454: .es
1455: .bs "C Tags"
1456: .es
1457: .es
1458: .bs "Error Message Parsing"
1459: .es
1460: .bs "Simple Customization"
1461: .bs "Minor Modes"
1462: .es
1463: .bs "Variables"
1464: .es
1465: .bs "Key Re-binding"
1466: .es
1467: .bs "Keyboard Macros"
1468: .es
1469: .bs "Initialization Files"
1470: .es
1471: .es
1472: .TC
1473: .hy 0

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.