Commit | Line | Data |
---|---|---|
ff262511 KB |
1 | .\" Copyright (c) 1986 The Regents of the University of California. |
2 | .\" All rights reserved. | |
3 | .\" | |
4 | .\" %sccs.include.redist.roff% | |
5 | .\" | |
6 | .\" @(#)jove.4 6.2 (Berkeley) %G% | |
42410e64 KM |
7 | .\" |
8 | .bp | |
9 | .NH 1 | |
10 | Alphabetical List of Commands and Variables | |
11 | .dc "Prefix-1" "Escape" | |
12 | This reads the next character and runs a command based on the character | |
13 | typed. If you wait for more than a second or so before typing the next | |
14 | character, the message "ESC" will be printed on the message line to | |
15 | remind you that \s-2JOVE\s0 is waiting for another character. | |
16 | .dc "Prefix-2" "C-X" | |
17 | This reads the next character and runs a command based on the character | |
18 | typed. If you wait for more than a second or so before typing another | |
19 | character, the message "C-X" will be printed on the message line to | |
20 | remind you that \s-2JOVE\s0 is waiting for another character. | |
21 | .dc "Prefix-3" "Not Bound" | |
22 | This reads the next character and runs a command based on the character | |
23 | typed. If you wait for more than a second or so before typing the next | |
24 | character, the character that invoked Prefix-3 will be printed on the | |
25 | message line to remind you that \s-2JOVE\s0 is waiting for another one. | |
26 | .dc "allow-^S-and-^Q" "(variable)" | |
27 | This variable, when set, tells \s-2JOVE\s0 that your terminal does not need | |
28 | to use the characters C-S and C-Q for flow control, and that it is | |
29 | okay to bind things to them. This variable should be set depending | |
30 | upon what kind of terminal you have. | |
31 | .dc "allow-bad-filenames" "(variable)" | |
32 | If set, this variable permits filenames to contain "bad" characters | |
33 | such as those from the set *&%!"`[]{}. These files are harder to deal | |
34 | with, because the characters mean something to the shell. The default | |
35 | value is "off". | |
36 | .dc "append-region" "Not Bound" | |
37 | This appends the region to a specified file. If the file does not | |
38 | already exist it is created. | |
39 | .dc "apropos" "Not Bound" | |
40 | This types out all the commands, variables and macros with the specific | |
41 | keyword in their names. For each command and macro that contains the | |
42 | string, the key sequence that can be used to execute the command or macro is | |
43 | printed; with variables, the current value is printed. So, to find all the | |
44 | commands that are related to windows, you type | |
45 | .DS | |
46 | ESC X apropos window<Return> | |
47 | .DE | |
48 | .dc "auto-case-abbrev" "(variable)" | |
49 | When this variable is on (the default), word abbreviations are adjusted for | |
50 | case automatically. For example, if "jove" were the abbreviation for | |
51 | "jonathan's own version of emacs", then typing "jove" would give you | |
52 | "jonathan's own version of emacs", typing "Jove" would give you "Jonathan's | |
53 | own version of emacs", and typing "JOVE" would give you "Jonathan's Own | |
54 | Version of Emacs". When this variable is "off", upper and lower case are | |
55 | distinguished when looking for the abbreviation, i.e., in the example above, | |
56 | "JOVE" and "Jove" would not be expanded unless they were defined separately. | |
57 | .dc "auto-execute-command" "Not Bound" | |
58 | This tells \s-2JOVE\s0 to execute a command automatically when a file whose | |
59 | name matches a specified pattern is visited. The first argument is the | |
60 | command you want executed and the second is a regular expression | |
61 | pattern that specifies the files that apply. For example, if you want | |
62 | to be in show-match-mode when you edit C source files (that is, files | |
63 | that end with ".c" or ".h") you can type | |
64 | .ID | |
65 | ESC X auto-execute-command show-match-mode .*\.[ch]$ | |
66 | .DE | |
67 | .dc "auto-execute-macro" "Not Bound" | |
68 | This is like | |
69 | .IQ auto-execute-command | |
70 | except you use it to execute macros | |
71 | automatically instead of built-in commands. | |
72 | .dc "auto-fill-mode" "Not Bound" | |
73 | This turns on Auto Fill mode (or off if it's currently on) in the | |
74 | selected buffer. When \s-2JOVE\s0 is in Auto Fill mode it automatically | |
75 | breaks lines for you when you reach the right margin so you don't have | |
76 | to remember to hit Return. \s-2JOVE\s0 uses 78 as the right margin but you | |
77 | can change that by setting the variable | |
78 | .IQ right-margin | |
79 | to another | |
80 | value. See the | |
81 | .IQ set | |
82 | command to learn how to do this. | |
83 | .dc "auto-indent-mode" "Not Bound" | |
84 | This turns on Auto Indent mode (or off if it's currently on) in the | |
85 | selected buffer. When \s-2JOVE\s0 is in Auto Indent mode, Return indents the | |
86 | new line to the same position as the line you were just on. This is | |
87 | useful for lining up C code (or any other language (but what else is | |
88 | there besides C?)). This is out of date because of the new command | |
89 | called | |
90 | .IQ newline-and-indent | |
91 | but it remains because of several | |
92 | "requests" on the part of, uh, enthusiastic and excitable users, that | |
93 | it be left as it is. | |
94 | .dc "backward-character" "C-B" | |
95 | This moves point backward over a single character. If point is at the | |
96 | beginning of the line it moves to the end of the previous line. | |
97 | .dc "backward-paragraph" "ESC [" | |
98 | This moves point backward to the beginning of the current or previous | |
99 | paragraph. Paragraphs are bounded by lines that begin with a Period or | |
100 | Tab, or by blank lines; a change in indentation may also signal a break | |
101 | between paragraphs, except that \s-2JOVE\s0 allows the first line of a paragraph | |
102 | to be indented differently from the other lines. | |
103 | .dc "backward-s-expression" "ESC C-B" | |
104 | This moves point backward over a s-expression. It is just like | |
105 | .IQ forward-s-expression | |
106 | with a negative argument. | |
107 | .dc "backward-sentence" "ESC A" | |
108 | This moves point backward to the beginning of the current or previous | |
109 | sentence. \s-2JOVE\s0 considers the end of a sentence to be the characters | |
110 | ".", "!" or "?" followed by a Return or by one or more spaces. | |
111 | .dc "backward-word" "ESC B" | |
112 | This moves point backward to the beginning of the current or previous | |
113 | word. | |
114 | .dc "bad-filename-extensions" "(variable)" | |
115 | This contains a list of words separated by spaces which are to be | |
116 | considered bad filename extensions, and so will not be counted in | |
117 | filename completion. The default is ".o" so if you have jove.c and | |
118 | jove.o in the same directory, the filename completion will | |
119 | .IQ not | |
120 | complain | |
121 | of an ambiguity because it will ignore jove.o. | |
122 | .dc "beginning-of-file" "ESC <" | |
123 | This moves point backward to the beginning of the buffer. This | |
124 | sometimes prints the "Point Pushed" message. If the top of the buffer | |
125 | isn't on the screen \s-2JOVE\s0 will set the mark so you can go back to where | |
126 | you were if you want. | |
127 | .dc "beginning-of-line" "C-A" | |
128 | This moves point to the beginning of the current line. | |
129 | .dc "beginning-of-window" "ESC ," | |
130 | This moves point to the beginning of the current window. The sequence | |
131 | "ESC ," is the same as "ESC <" (beginning of file) except without the shift | |
132 | key on the "<", and can thus can easily be remembered. | |
133 | .dc "bind-to-key" "Not Bound" | |
134 | This attaches a key to an internal \s-2JOVE\s0 command so that future hits on | |
135 | that key invoke that command. For example, to make "C-W" erase the | |
136 | previous word, you type "ESC X bind-to-key kill-previous-word C-W". | |
137 | .dc "bind-macro-to-key" "Not Bound" | |
138 | This is like | |
139 | .IQ bind-to-key | |
140 | except you use it to attach keys to | |
141 | named macros. | |
142 | .dc "bind-macro-to-word-abbrev" "Not Bound" | |
143 | This command allows you to bind a macro to a previously defined word | |
144 | abbreviation. Whenever you type the abbreviation, it will first be expanded | |
145 | as an abbreviation, and then the macro will be executed. Note that if the | |
146 | macro moves around, you should set the mark first (C-@) and then exchange | |
147 | the point and mark last (C-X C-X). | |
148 | .dc "buffer-position" "Not Bound" | |
149 | This displays the current file name, current line number, total number | |
150 | of lines, percentage of the way through the file, and the position of | |
151 | the cursor in the current line. | |
152 | .dc "c-mode" "Not Bound" | |
153 | This turns on C mode in the currently selected buffer. This is one of | |
154 | currently four possible major modes: Fundamental, Text, C, Lisp. | |
155 | When in C or Lisp mode, Tab, "}", and ")" behave a little differently | |
156 | from usual: They are indented to the "right" place for C (or Lisp) | |
157 | programs. In \s-2JOVE\s0, the "right" place is simply the way the author | |
158 | likes it (but I've got good taste). | |
159 | .dc "case-character-capitalize" "Not Bound" | |
160 | This capitalizes the character after point, i.e., the character undo | |
161 | the cursor. If a negative argument is supplied that many characters | |
162 | .IQ before | |
163 | point are upper cased. | |
164 | .dc "case-ignore-search" "(variable)" | |
165 | This variable, when set, tells \s-2JOVE\s0 to treat upper and lower case as | |
166 | the same when searching. Thus "jove" and "JOVE" would match, and | |
167 | "JoVe" would match either. The default value of this variable is "off". | |
168 | .dc "case-region-lower" "Not Bound" | |
169 | This changes all the upper case letters in the region to their lower | |
170 | case equivalent. | |
171 | .dc "case-region-upper" "Not Bound" | |
172 | This changes all the lower case letters in the region to their upper | |
173 | case equivalent. | |
174 | .dc "case-word-capitalize" "ESC C" | |
175 | This capitalizes the current word by making the current letter upper | |
176 | case and making the rest of the word lower case. Point is moved to | |
177 | the end of the word. If point is not positioned on a word it is first | |
178 | moved forward to the beginning of the next word. If a negative | |
179 | argument is supplied that many words | |
180 | .IQ before | |
181 | point are capitalized. | |
182 | This is useful for correcting the word just typed without having to | |
183 | move point to the beginning of the word yourself. | |
184 | .dc "case-word-lower" "ESC L" | |
185 | This lower-cases the current word and leaves point at the end of it. | |
186 | If point is in the middle of a word the rest of the word is | |
187 | converted. If point is not in a word it is first moved forward to the | |
188 | beginning of the next word. If a negative argument is supplied that | |
189 | many words | |
190 | .IQ before | |
191 | point are converted to lower case. This is useful | |
192 | for correcting the word just typed without having to move point to the | |
193 | beginning of the word yourself. | |
194 | .dc "case-word-upper" "ESC U" | |
195 | This upper-cases the current word and leaves point at the end of it. | |
196 | If point is in the middle of a word the rest of the word is | |
197 | converted. If point is not in a word it is first moved forward to the | |
198 | beginning of the next word. If a negative argument is supplied that | |
199 | many words | |
200 | .IQ before | |
201 | point are converted to upper case. This is useful | |
202 | for correcting the word just typed without having to move point to the | |
203 | beginning of the word yourself. | |
204 | .dc "character-to-octal-insert" "Not Bound" | |
205 | This inserts a Back-slash followed by the ascii value of the next | |
206 | character typed. For example, "C-G" inserts the string "\\007". | |
207 | .dc "cd" "Not Bound" | |
208 | This changes the current directory. | |
209 | .dc "clear-and-redraw" "ESC C-L" | |
210 | This clears the entire screen and redraws all the windows. Use this | |
211 | when \s-2JOVE\s0 gets confused about what's on the screen, or when the screen | |
212 | gets filled with garbage characters or output from another program. | |
213 | .dc "comment-format" "(variable)" | |
214 | This variable tells \s-2JOVE\s0 how to format your comments when you run the | |
215 | command | |
216 | .IQ fill-comment. | |
217 | Its format is this: | |
218 | .ID | |
219 | <open pattern>%!<line header>%c<line trailer>%!<close pattern> | |
220 | .DE | |
221 | The %!, %c, and %! must appear in the format; everything else is optional. | |
222 | A newline (represented by %n) may appear in the open or close patterns. %% | |
223 | is the representation for %. The default comment format is for C comments. | |
224 | See | |
225 | .IQ fill-comment | |
226 | for more. | |
227 | .dc "compile-it" "C-X C-E" | |
228 | This compiles your program by running the UNIX command "make" into a buffer, | |
229 | and automatically parsing the error messages that are created (if any). See | |
230 | the | |
231 | .IQ parse-errors | |
232 | and | |
233 | .IQ parse-special-errors | |
234 | commands. To compile | |
235 | a C program without "make", use "C-U C-X C-E" and \s-2JOVE\s0 will prompt | |
236 | for a command to run instead of make. (And then the command you type will | |
237 | become the default command.) You can use this to parse the output from the | |
238 | C compiler or the "grep" or "lint" programs. | |
239 | .dc "continue-process" "Not Bound" | |
240 | This sends SIGCONT to the current interactive process, | |
241 | .IQ if | |
242 | the process | |
243 | is currently stopped. | |
244 | .dc "copy-region" "ESC W" | |
245 | This takes all the text in the region and copies it onto the kill ring | |
246 | buffer. This is just like running | |
247 | .IQ kill-region | |
248 | followed by the | |
249 | .IQ yank | |
250 | command. See the | |
251 | .IQ kill-region | |
252 | and | |
253 | .IQ yank | |
254 | commands. | |
255 | .dc "current-error" "Not Bound" | |
256 | This moves to the current error in the list of parsed errors. See the | |
257 | .IQ next-error | |
258 | and | |
259 | .IQ previous-error | |
260 | commands for more detailed | |
261 | information. | |
262 | .dc "date" "Not Bound" | |
263 | This prints the date on the message line. | |
264 | .dc "define-mode-word-abbrev" "Not Bound" | |
265 | This defines a mode-specific abbreviation. | |
266 | .dc "define-global-word-abbrev" "Not Bound" | |
267 | This defines a global abbreviation. | |
268 | .dc "delete-blank-lines" "C-X C-O" | |
269 | This deletes all the blank lines around point. This is useful when you | |
270 | previously opened many lines with "C-O" and now wish to delete the | |
271 | unused ones. | |
272 | .dc "delete-buffer" "C-X K" | |
273 | This deletes a buffer and frees up all the memory associated with it. | |
274 | Be careful! Once a buffer has been deleted it is gone forever. \s-2JOVE\s0 | |
275 | will ask you to confirm if you try to delete a buffer that needs | |
276 | saving. This command is useful for when \s-2JOVE\s0 runs out of space to | |
277 | store new buffers. | |
278 | .dc "delete-macro" "Not Bound" | |
279 | This deletes a macro from the list of named macros. It is an error to | |
280 | delete the keyboard-macro. Once the macro is deleted it is gone forever. | |
281 | If you are about to save macros to a file and decide you don't want to save | |
282 | a particular one, delete it. | |
283 | .dc "delete-next-character" "C-D" | |
284 | This deletes the character that's just after point (that is, the | |
285 | character under the cursor). If point is at the end of a line, the | |
286 | line separator is deleted and the next line is joined with the current | |
287 | one. | |
288 | .dc "delete-other-windows" "C-X 1" | |
289 | This deletes all the other windows except the current one. This can be | |
290 | thought of as going back into One Window mode. | |
291 | .dc "delete-previous-character" "Rubout" | |
292 | This deletes the character that's just before point (that is, the | |
293 | character before the cursor). If point is at the beginning of the | |
294 | line, the line separator is deleted and that line is joined with the | |
295 | previous one. | |
296 | .dc "delete-white-space" "ESC \\\\" | |
297 | This deletes all the Tabs and Spaces around point. | |
298 | .dc "delete-current-window" "C-X D" | |
299 | This deletes the current window and moves point into one of the | |
300 | remaining ones. It is an error to try to delete the only remaining | |
301 | window. | |
302 | .dc "describe-bindings" "Not Bound" | |
303 | This types out a list containing each bound key and the command that gets | |
304 | invoked every time that key is typed. To make a wall chart of \s-2JOVE\s0 | |
305 | commands, set | |
306 | .IQ send-typeout-to-buffer | |
307 | to "on" and \s-2JOVE\s0 will | |
308 | store the key bindings in a buffer which you can save to a file and then | |
309 | print. | |
310 | .dc "describe-command" "Not Bound" | |
311 | This prints some info on a specified command. | |
312 | .dc "describe-key" "Not Bound" | |
313 | This waits for you to type a key and then tells the name of the | |
314 | command that gets invoked every time that key is hit. Once you have | |
315 | the name of the command you can use the | |
316 | .IQ describe-command | |
317 | command | |
318 | to find out exactly what it does. | |
319 | .dc "describe-variable" "Not Bound" | |
320 | This prints some info on a specified variable. | |
321 | .dc "digit" "ESC [0-9]" | |
322 | This reads a numeric argument. When you type "ESC" followed by a | |
323 | number, "digit" keeps reading numbers until you type some other | |
324 | command. Then that command is executes with the numeric argument you | |
325 | specified. | |
326 | .dc "digit-1" "Not Bound" | |
327 | This pretends you typed "ESC 1". This is useful for terminals that | |
328 | have keypads that send special sequences for numbers typed on the | |
329 | keypad as opposed to numbers typed from the keyboard. This can save | |
330 | having type "ESC" when you want to specify an argument. | |
331 | .dc "digit-2" "Not Bound" | |
332 | This pretends you typed "ESC 2". This is useful for terminals that | |
333 | have keypads that send special sequences for numbers typed on the | |
334 | keypad as opposed to numbers typed from the keyboard. This can save | |
335 | having type "ESC" when you want to specify an argument. | |
336 | .dc "digit-3" "Not Bound" | |
337 | This pretends you typed "ESC 3". This is useful for terminals that | |
338 | have keypads that send special sequences for numbers typed on the | |
339 | keypad as opposed to numbers typed from the keyboard. This can save | |
340 | having type "ESC" when you want to specify an argument. | |
341 | .dc "digit-4" "Not Bound" | |
342 | This pretends you typed "ESC 4". This is useful for terminals that | |
343 | have keypads that send special sequences for numbers typed on the | |
344 | keypad as opposed to numbers typed from the keyboard. This can save | |
345 | having type "ESC" when you want to specify an argument. | |
346 | .dc "digit-5" "Not Bound" | |
347 | This pretends you typed "ESC 5". This is useful for terminals that | |
348 | have keypads that send special sequences for numbers typed on the | |
349 | keypad as opposed to numbers typed from the keyboard. This can save | |
350 | having type "ESC" when you want to specify an argument. | |
351 | .dc "digit-6" "Not Bound" | |
352 | This pretends you typed "ESC 6". This is useful for terminals that | |
353 | have keypads that send special sequences for numbers typed on the | |
354 | keypad as opposed to numbers typed from the keyboard. This can save | |
355 | having type "ESC" when you want to specify an argument. | |
356 | .dc "digit-7" "Not Bound" | |
357 | This pretends you typed "ESC 7". This is useful for terminals that | |
358 | have keypads that send special sequences for numbers typed on the | |
359 | keypad as opposed to numbers typed from the keyboard. This can save | |
360 | having type "ESC" when you want to specify an argument. | |
361 | .dc "digit-8" "Not Bound" | |
362 | This pretends you typed "ESC 8". This is useful for terminals that | |
363 | have keypads that send special sequences for numbers typed on the | |
364 | keypad as opposed to numbers typed from the keyboard. This can save | |
365 | having type "ESC" when you want to specify an argument. | |
366 | .dc "digit-9" "Not Bound" | |
367 | This pretends you typed "ESC 9". This is useful for terminals that | |
368 | have keypads that send special sequences for numbers typed on the | |
369 | keypad as opposed to numbers typed from the keyboard. This can save | |
370 | having type "ESC" when you want to specify an argument. | |
371 | .dc "digit-0" "Not Bound" | |
372 | This pretends you typed "ESC 0". This is useful for terminals that | |
373 | have keypads that send special sequences for numbers typed on the | |
374 | keypad as opposed to numbers typed from the keyboard. This can save | |
375 | having type "ESC" when you want to specify an argument. | |
376 | .dc "dirs" "Not Bound" | |
377 | This prints out the directory stack. See the "cd", "pushd", "popd" | |
378 | commands for more info. | |
379 | .dc "disable-biff" "(variable)" | |
380 | When this is set, \s-2JOVE\s0 disables biff when you're editing and enables it | |
381 | again when you get out of \s-2JOVE\s0, or when you pause to the parent shell | |
382 | or push to a new shell. (This means arrival of new mail will not be | |
383 | immediately apparent but will not cause indiscriminate writing on the | |
384 | display). The default is "off". | |
385 | .dc "dstop-process" "Not Bound" | |
386 | Send the "dsusp" character to the current process. This is the | |
387 | character that suspends a process on the next read from the | |
388 | terminal. Most people have it set to C-Y. This only works if | |
389 | you have the interactive process feature, and if you are in a | |
390 | buffer bound to a process. | |
391 | .dc "edit-word-abbrevs" "Not Bound" | |
392 | This creates a buffer with a list of each abbreviation and the phrase | |
393 | it expands into, and enters a recursive edit to let you change the | |
394 | abbreviations or add some more. The format of this list is | |
395 | "abbreviation:phrase" so if you add some more you should follow that | |
396 | format. It's probably simplest just to copy some already existing | |
397 | abbreviations and edit them. When you are done you type "C-X C-C" to | |
398 | exit the recursive edit. | |
399 | .dc "end-of-file" "ESC >" | |
400 | This moves point forward to the end of the buffer. This sometimes | |
401 | prints the "Point Pushed" message. If the end of the buffer isn't on | |
402 | the screen \s-2JOVE\s0 will set the mark so you can go back to where you were | |
403 | if you want. | |
404 | .dc "end-of-line" "C-E" | |
405 | This moves point to the end of the current line. If the line is too | |
406 | long to fit on the screen \s-2JOVE\s0 will scroll the line to the left to | |
407 | make the end of the line visible. The line will slide back to its | |
408 | normal position when you move backward past the leftmost visible character | |
409 | or when you move off the line altogether. | |
410 | .dc "end-of-window" "ESC ." | |
411 | This moves point to the last character in the window. | |
412 | .dc "eof-process" "Not Bound" | |
413 | Sends EOF to the current interactive process. This only works on | |
414 | versions of \s-2JOVE\s0 which run under 4.2-3 BSD VAX UNIX. You can't send | |
415 | EOF to processes on the 2.9 BSD PDP-11 UNIX. | |
416 | .dc "erase-buffer" "Not Bound" | |
417 | This erases the contents of the specified buffer. This is like | |
418 | .IQ delete-buffer | |
419 | except it only erases the contents of the buffer, not | |
420 | the buffer itself. If you try to erase a buffer that needs saving you | |
421 | will be asked to confirm it. | |
422 | .dc "error-window-size" "(variable)" | |
423 | This is the percentage of the screen to use for the error-window on the | |
424 | screen. When you execute | |
425 | .IQ compile-it, | |
426 | .IQ error-window-size | |
427 | percent of the screen will go to the error window. If the window already | |
428 | exists and is a different size, it is made to be this size. The default | |
429 | value is 20%. | |
430 | .dc "exchange-point-and-mark" "C-X C-X" | |
431 | This moves point to mark and makes mark the old point. This is for | |
432 | quickly moving from one end of the region to another. | |
433 | .dc "execute-named-command" "ESC X" | |
434 | This is the way to execute a command that isn't bound to any key. | |
435 | When you are prompted with ": " you can type the name of the | |
436 | command. You don't have to type the entire name. Once the command | |
437 | is unambiguous you can type Space and \s-2JOVE\s0 will fill in the rest for | |
438 | you. | |
439 | If you are not sure of the name of the command, type "?" and \s-2JOVE\s0 | |
440 | will print a list of all the commands that you could possibly match | |
441 | given what you've already typed. If you don't have any idea what the | |
442 | command's name is but you know it has something to do with windows | |
443 | (for example), you can do "ESC X apropos window" and \s-2JOVE\s0 will print a | |
444 | list of all the commands that are related to windows. | |
445 | If you find yourself constantly executing the same commands this way | |
446 | you probably want to bind them to keys so that you can execute them | |
447 | more quickly. See the | |
448 | .IQ bind-to-key | |
449 | command. | |
450 | .dc "execute-keyboard-macro" "C-X E" | |
451 | This executes the keyboard macro. If you supply a numeric argument the | |
452 | macro is executed that many times. | |
453 | .dc "execute-macro" "Not Bound" | |
454 | This executes a specified macro. If you supply a numeric argument the | |
455 | macro is executed that many times. | |
456 | .dc "exit-jove" "C-X C-C" | |
457 | This exits \s-2JOVE\s0. If any buffers need saving \s-2JOVE\s0 will print a warning | |
458 | message and ask for confirmation. If you leave without saving your | |
459 | buffers all your work will be lost. If you made a mistake and really | |
460 | do want to exit then you can. If you are in a recursive editing level | |
461 | .IQ exit-jove | |
462 | will return you from that. | |
463 | .dc "file-creation-mode" "(variable)" | |
464 | This variable has an octal value. | |
465 | It contains the mode (see | |
466 | .IQ chmod(1) | |
467 | ) with which files should be created. This mode gets modified by your | |
468 | current umask setting (see | |
469 | .IQ umask(1) | |
470 | ). The default value is usually | |
471 | .IQ 0666 | |
472 | or | |
473 | .IQ 0644. | |
474 | .dc "files-should-end-with-newline" "(variable)" | |
475 | This variable indicates that all files should always have a newline | |
476 | at the end. This is often necessary for line printers and the like. | |
477 | When set, if \s-2JOVE\s0 is writing a file whose last character is not a | |
478 | newline, it will add one automatically. | |
479 | .dc "fill-comment" "Not Bound" | |
480 | This command fills in your C comments to make them pretty and readable. | |
481 | This filling is done according the variable | |
482 | .IQ comment-format. | |
483 | .DS L | |
484 | /* | |
485 | * the default format makes comments like this. | |
486 | */ | |
487 | .DE | |
488 | This can be changed by changing the format variable. Other languages | |
489 | may be supported by changing the format variable appropriately. The | |
490 | formatter looks backwards from dot for an open comment symbol. If | |
491 | found, all indentation is done relative the position of the first character | |
492 | of the open symbol. If there is a matching close symbol, the entire | |
493 | comment is formatted. If not, the region between dot and the open symbol | |
494 | is reformatted. | |
495 | .dc "fill-paragraph" "ESC J" | |
496 | This rearranges words between lines so that all the lines in the current | |
497 | paragraph extend as close to the right margin as possible, ensuring that | |
498 | none of the lines will be greater than the right margin. The default value | |
499 | for | |
500 | .IQ right-margin | |
501 | is 78, but can be changed with the | |
502 | .IQ set | |
503 | and | |
504 | .IQ right-margin-here | |
505 | commands. \s-2JOVE\s0 has a complicated algorithm | |
506 | for determining the beginning and end of the paragraph. In the normal case | |
507 | \s-2JOVE\s0 will give all the lines the same indent as they currently have, | |
508 | but if you wish to force a new indent you can supply a numeric argument to | |
509 | .IQ fill-paragraph | |
510 | (e.g., by typing C-U ESC J) | |
511 | and \s-2JOVE\s0 will indent each line to the column | |
512 | specified by the | |
513 | .IQ left-margin | |
514 | variable. See also the | |
515 | .IQ left-margin | |
516 | variable and | |
517 | .IQ left-margin-here | |
518 | command. | |
519 | .dc "fill-region" "Not Bound" | |
520 | This is like | |
521 | .IQ fill-paragraph, | |
522 | except it operates on a region instead of | |
523 | just a paragraph. | |
524 | .dc "filter-region" "Not Bound" | |
525 | This sends the text in the region to a UNIX command, and replaces the | |
526 | region with the output from that command. For example, if you are | |
527 | lazy and don't like to take the time to write properly indented C | |
528 | code, you can put the region around your C file and | |
529 | .IQ filter-region | |
530 | it | |
531 | through | |
532 | .IQ cb, | |
533 | the UNIX C beautifier. If you have a file that contains | |
534 | a bunch of lines that need to be sorted you can do that from inside | |
535 | \s-2JOVE\s0 too, by filtering the region through the | |
536 | .IQ sort | |
537 | UNIX command. | |
538 | Before output from the command replaces the region \s-2JOVE\s0 stores the old | |
539 | text in the kill ring, so if you are unhappy with the results you can | |
540 | easily get back the old text with "C-Y". | |
541 | .dc "find-file" "C-X C-F" | |
542 | This visits a file into its own buffer and then selects that buffer. | |
543 | If you've already visited this file in another buffer, that buffer is | |
544 | selected. If the file doesn't yet exist, \s-2JOVE\s0 will print "(New file)" | |
545 | so that you know. | |
546 | .dc "find-tag" "C-X T" | |
547 | This finds the file that contains the specified tag. \s-2JOVE\s0 looks up | |
548 | tags by default in the "tags" file in the current directory. You can change | |
549 | the default tag name by setting the | |
550 | .IQ tag-file | |
551 | variable to another | |
552 | name. If you specify a numeric argument to this command, you will be | |
553 | prompted for a tag file. This is a good way to specify another tag file | |
554 | without changing the default. If the tag cannot be found the error is | |
555 | reported and point stays where it is. | |
556 | .dc "find-tag-at-point" "Not Bound" | |
557 | This finds the file that contains the tag that point is currently on. | |
558 | See | |
559 | .IQ find-tag. | |
560 | .dc "first-non-blank" "ESC M" | |
561 | This moves point back to the indent of the current line. | |
562 | .dc "forward-character" "C-F" | |
563 | This moves forward over a single character. If point is at the end of | |
564 | the line it moves to the beginning of the next one. | |
565 | .dc "forward-paragraph" "ESC ]" | |
566 | This moves point forward to the end of the current or next paragraph. | |
567 | Paragraphs are bounded by lines that begin with a Period or Tab, or by blank | |
568 | lines; a change in indentation may also signal a break between paragraphs, | |
569 | except that \s-2JOVE\s0 allows the first line of a paragraph to be indented | |
570 | differently from the other lines. | |
571 | .dc "forward-s-expression" "ESC C-F" | |
572 | This moves point forward over a s-expression. If the first significant | |
573 | character after point is "(", this moves past the matching ")". If the | |
574 | character begins an identifier, this moves just past it. This is mode | |
575 | dependent, so this will move over atoms in LISP mode and C identifiers in C | |
576 | mode. \s-2JOVE\s0 also matches "{". | |
577 | .dc "forward-sentence" "ESC E" | |
578 | This moves point forward to the end of the current or next sentence. | |
579 | \s-2JOVE\s0 considers the end of a sentence to be the characters ".", "!" or | |
580 | "?" followed by a Return, or one or more spaces. | |
581 | .dc "forward-word" "ESC F" | |
582 | This moves point forward to the end of the current or next word. | |
583 | .dc "fundamental-mode" "Not Bound" | |
584 | This sets the major mode to Fundamental. This affects what \s-2JOVE\s0 | |
585 | considers as characters that make up words. For instance, | |
586 | Single-quote is not part of a word in Fundamental mode, but is in Text | |
587 | mode. | |
588 | .dc "goto-line" "ESC G" | |
589 | If a numeric argument is supplied point moves to the beginning of that | |
590 | line. If no argument is supplied, point remains where it is. This is | |
591 | so you don't lose your place unintentionally, by accidentally hitting | |
592 | the "G" instead of "F". | |
593 | .dc "grind-s-expr" "Not Bound" | |
594 | When point is positioned on a "(", this re-indents that LISP expression. | |
595 | .dc "grow-window" "C-X ^" | |
596 | This makes the current window one line bigger. This only works when | |
597 | there is more than one window and provided there is room to change the | |
598 | size. | |
599 | .dc "paren-flash" ") } ]" | |
600 | This handles the C mode curly brace indentation, the Lisp mode paren | |
601 | indentation, and the Show Match mode paren/curly brace/square bracket | |
602 | flashing. | |
603 | .dc "handle-tab" "Tab" | |
604 | This handles indenting to the "right" place in C and Lisp mode, and | |
605 | just inserts itself in Text mode. | |
606 | .dc "i-search-forward" "Not Bound" | |
607 | Incremental search. Like search-forward except that instead of prompting | |
608 | for a string and searching for that string all at once, it accepts the string | |
609 | one character at a time. After each character you type as part of the search | |
610 | string, it searches for the entire string so far. When you like what it | |
611 | found, type the Return key to finish the search. You can take back a | |
612 | character with Rubout and the search will back up to the position before | |
613 | that character was typed. C-G aborts the search. | |
614 | .dc "i-search-reverse" "Not Bound" | |
615 | Incremental search. Like search-reverse except that instead of prompting | |
616 | for a string and searching for that string all at once, it accepts the string | |
617 | one character at a time. After each character you type as part of the search | |
618 | string, it searches for the entire string so far. When you like what it | |
619 | found, type the Return key to finish the search. You can take back a | |
620 | character with Rubout and the search will back up to the position before | |
621 | that character was typed. C-G aborts the search. | |
622 | .dc "insert-file" "C-X C-I" | |
623 | This inserts a specified file into the current buffer at point. Point | |
624 | is positioned at the beginning of the inserted file. | |
625 | .dc "internal-tabstop" "(variable)" | |
626 | The number of spaces \s-2JOVE\s0 should print when it displays a tab character. | |
627 | The default value is 8. | |
628 | .dc "interrupt-process" "Not Bound" | |
629 | This sends the interrupt character (usually C-C) to the interactive process | |
630 | in the current buffer. This is only for versions of \s-2JOVE\s0 that have the | |
631 | interactive processes feature. This only works when you are inside a buffer | |
632 | that's attached to a process. | |
633 | .dc "i-shell" "Not Bound" | |
634 | This starts up an interactive shell in a window. \s-2JOVE\s0 uses "shell-1" | |
635 | as the name of the buffer in which the interacting takes place. See | |
636 | the manual for information on how to use interactive processes. | |
637 | .dc "i-shell-command" "Not Bound" | |
638 | This is like | |
639 | .IQ shell-command | |
640 | except it lets you continue with your | |
641 | editing while the command is running. This is really useful for long | |
642 | running commands with sporadic output. See the manual for information | |
643 | on how to use interactive processes. | |
644 | .dc "kill-next-word" "ESC D" | |
645 | This kills the text from point to the end of the current or next word. | |
646 | .dc "kill-previous-word" "ESC Rubout" | |
647 | This kills the text from point to the beginning of the current or | |
648 | previous word. | |
649 | .dc "kill-process" "Not Bound" | |
650 | This command prompts for a buffer name or buffer number (just as | |
651 | select-buffer does) and then sends the process in that buffer a | |
652 | kill signal (9). | |
653 | .dc "kill-region" "C-W" | |
654 | This deletes the text in the region and saves it on the kill ring. | |
655 | Commands that delete text but save it on the kill ring all have the | |
656 | word "kill" in their names. Type "C-Y" to yank back the most recent | |
657 | kill. | |
658 | .dc "kill-s-expression" "ESC C-K" | |
659 | This kills the text from point to the end of the current or next | |
660 | s-expression. | |
661 | .dc "kill-some-buffers" "Not Bound" | |
662 | This goes through all the existing buffers and asks whether or not to kill | |
663 | them. If you decide to kill a buffer, and it turns out that the buffer is | |
664 | modified, \s-2JOVE\s0 will offer to save it first. This is useful for when \s-2JOVE\s0 | |
665 | runs out of memory to store lines (this only happens on PDP-11's) and you | |
666 | have lots of buffers that you are no longer using. | |
667 | .dc "kill-to-beginning-of-sentence" "C-X Rubout" | |
668 | This kills from point to the beginning of the current or previous | |
669 | sentence. | |
670 | .dc "kill-to-end-of-line" "C-K" | |
671 | This kills from point to the end of the current line. When point is | |
672 | at the end of the line the line separator is deleted and the next line | |
673 | is joined with current one. If a numeric argument is supplied that | |
674 | many lines are killed; if the argument is negative that many lines | |
675 | .IQ before | |
676 | point are killed; if the argument is zero the text from point | |
677 | to the beginning of the line is killed. | |
678 | .dc "kill-to-end-of-sentence" "ESC K" | |
679 | This kills from point to the end of the current or next sentence. If a | |
680 | negative numeric argument is supplied it kills from point to the | |
681 | beginning of the current or previous sentence. | |
682 | .dc "left-margin" "(variable)" | |
683 | This is how far lines should be indented when auto-indent mode is on, | |
684 | or when the | |
685 | .IQ newline-and-indent | |
686 | command is run (usually by typing | |
687 | LineFeed). It is also used by fill-paragraph and auto-fill mode. | |
688 | If the value is zero (the default) then the left margin is determined | |
689 | from the surrounding lines. | |
690 | .dc "left-margin-here" "Not Bound" | |
691 | This sets the | |
692 | .IQ left-margin | |
693 | variable to the current position of | |
694 | point. This is an easy way to say, "Make the left margin begin here," | |
695 | without having to count the number of spaces over it actually is. | |
696 | .dc "lisp-mode" "Not Bound" | |
697 | This turns on Lisp mode. Lisp mode is one of four mutually exclusive major | |
698 | modes: Fundamental, Text, C, and Lisp. In Lisp mode, the characters Tab | |
699 | and ) are treated specially, similar to the way they are treated in C mode. | |
700 | Also, Auto Indent mode is affected, and handled specially. | |
701 | .dc "list-buffers" "C-X C-B" | |
702 | This types out a list containing various information about each buffer. | |
703 | Right now that list looks like this: | |
704 | .DS | |
705 | .ta \w'NO111'u +\w'Lines1'u +\w'Scratch111'u +\w'*1'u +\w'commands.doc111'u | |
706 | \ (* means the buffer needs saving) | |
707 | \ NO Lines Type Name File | |
708 | \ -- ----- ---- ---- ---- | |
709 | \ 1 1 File Main [No file] | |
710 | \ 2 1 Scratch * Minibuf [No file] | |
711 | \ 3 519 File * commands.doc commands.doc | |
712 | .DE | |
713 | The first column lists the buffer's number. When \s-2JOVE\s0 prompts for a | |
714 | buffer name you can either type in the full name, or you can simply | |
715 | type the buffer's number. The second column is the number of lines in | |
716 | the buffer. The third says what type of buffer. There are four | |
717 | types: "File", "Scratch", "Process", "I-Process". "File" is simply a | |
718 | buffer that holds a file; "Scratch" is for buffers that \s-2JOVE\s0 uses | |
719 | internally; "Process" is one that holds the output from a UNIX | |
720 | command; "I-Process" is one that has an interactive process attached to | |
721 | it. The next column contains the name of the buffer. And the last | |
722 | column is the name of the file that's attached to the buffer. In this | |
723 | case, both Minibuf and commands.doc have been changed but not yet | |
724 | saved. In fact Minibuf won't be saved since it's an internal \s-2JOVE\s0 | |
725 | buffer that I don't even care about. | |
726 | .dc "list-processes" "Not Bound" | |
727 | This makes a list somewhat like "list-buffers" does, except its | |
728 | list consists of the current interactive processes. Right now the list | |
729 | looks like this: | |
730 | .DS | |
731 | .ta \w'shell-111111111111'u +\w'Running1111111111'u | |
732 | \ Buffer Status Command name | |
733 | \ ------ ------ ------- ---- | |
734 | \ shell-1 Running i-shell | |
735 | \ fgrep Done fgrep -n Buffer *.c | |
736 | .DE | |
737 | The first column has the name of the buffer to which the process is | |
738 | attached. The second has the status of the process; if a process has | |
739 | exited normally the status is "Done" as in fgrep; if the process | |
740 | exited with an error the status is "Exit N" where N is the value of | |
741 | the exit code; if the process was killed by some signal the status is | |
742 | the name of the signal that was used; otherwise the process is | |
743 | running. The last column is the name of the command that is being run. | |
744 | .dc "mailbox" "(variable)" | |
745 | Set this to the full pathname of your mailbox. \s-2JOVE\s0 will look here to | |
746 | decide whether or not you have any unread mail. This defaults to | |
747 | /usr/spool/mail/$USER, where $USER is set to your login name. | |
748 | .dc "mail-check-frequency" "(variable)" | |
749 | This is how often (in seconds) \s-2JOVE\s0 should check your mailbox for | |
750 | incoming mail. See also the | |
751 | .IQ mailbox | |
752 | and | |
753 | .IQ disable-biff | |
754 | variables. | |
755 | .dc "make-backup-files" "(variable)" | |
756 | If this variable is set, then whenever \s-2JOVE\s0 writes out a file, it will | |
757 | move the previous version of the file (if there was one) to "#filename". | |
758 | This is often convenient if you save a file by accident. The default | |
759 | value of this variable is "off". | |
760 | .IQ Note: | |
761 | this is an optional part of | |
762 | \s-2JOVE\s0, and your guru may not have it enabled, so it may not work. | |
763 | .dc "make-buffer-unmodified" "ESC ~" | |
764 | This makes \s-2JOVE\s0 think the selected buffer hasn't been changed even if | |
765 | it has. Use this when you accidentally change the buffer but don't | |
766 | want it considered changed. Watch the mode line to see the * disappear | |
767 | when you use this command. | |
768 | .dc "make-macro-interactive" "Not Bound" | |
769 | This command is meaningful only while you are defining a keyboard macro. | |
770 | Ordinarily, when a command in a macro definition requires a trailing | |
771 | text argument (file name, search string, etc.), the argument you | |
772 | supply becomes part of the macro definition. If you want to be able | |
773 | to supply a different argument each time the macro is used, then while | |
774 | you are defining it, you should give the make-macro-interactive | |
775 | command just before typing the argument which will be used during the | |
776 | definition process. Note: you must bind this command to a key in | |
777 | order to use it; you can't say ESC X make-macro-interactive. | |
778 | .dc "mark-threshold" "(variable)" | |
779 | This variable contains the number of lines point may move by before | |
780 | the mark is set. If, in a search or something, point moves by more | |
781 | than this many lines, the mark is set so that you may return easily. | |
782 | The default value of this variable is 22 (one screenful, on most | |
783 | terminals). | |
784 | .dc "marks-should-float" "(variable)" | |
785 | When this variable is "off", the position of a mark is remembered as a line | |
786 | number within the buffer and a character number within the line. If you add | |
787 | or delete text before the mark, it will no longer point to the text you | |
788 | marked originally because that text is no longer at the same line and | |
789 | character number. When this variable is "on", the position of a mark is | |
790 | adjusted to compensate for each insertion and deletion. This makes marks | |
791 | much more sensible to use, at the cost of slowing down insertion and | |
792 | deletion somewhat. The default value is "on". | |
793 | .dc "match-regular-expressions" "(variable)" | |
794 | When set, \s-2JOVE\s0 will match regular expressions in search patterns. | |
795 | This makes special the characters ., *, [, ], ^, and $, and the two-character | |
796 | sequences \e<, \e>, \e\|{, \e\|} and \e\||. | |
797 | See the | |
798 | .IQ ed(1) | |
799 | manual page, the tutorial "Advanced Editing in | |
800 | .UX | |
801 | ", and the section above "Searching with Regular Expressions" | |
802 | for more information. | |
803 | .dc "meta-key" "(variable)" | |
804 | You should set this variable to "on" if your terminal has a real Meta | |
805 | key. | |
806 | If your terminal has such a key, then a key sequence like ESC Y can | |
807 | be entered by holding down Meta and typing Y. | |
808 | .dc "mode-line" "(variable)" | |
809 | The format of the mode line can be determined by setting this variable. | |
810 | The items in the line are specified using a printf(3) format, with the | |
811 | special things being marked as "%x". Digits may be used between the | |
812 | '%' and the 'x' to mean repeat that many times. | |
813 | \&'x' may be: | |
814 | .DS I | |
815 | .ta .5i 1i 1.5i | |
816 | C check for new mail, and displays "[New mail]" if there | |
817 | is any (see also the mail-check-interval and disable-biff | |
818 | variables) | |
819 | F the current file name, with leading path stripped | |
820 | M the current list of major and minor modes | |
821 | b the current buffer name | |
822 | c the fill character (-) | |
823 | d the current directory | |
824 | e end of string--this must be the last item in the string | |
825 | f the current file name | |
826 | l the current load average (updated automatically) | |
827 | m the buffer-modified symbol (*) | |
828 | n the current buffer number | |
829 | s space, but only if previous character is not a space | |
830 | t the current time (updated automatically) | |
831 | [ ] the square brackets printed when in a recursive edit | |
832 | ( ) items enclosed in %( ... %) will only be printed on | |
833 | the bottom mode line, rather than copied when the | |
834 | window is split | |
835 | .DE | |
836 | In addition, any other character is simply copied into the mode line. | |
837 | Characters may be escaped with a backslash. To get a feel for all | |
838 | this, try typing "ESC X print mode-line" and compare the result with | |
839 | your current mode line. | |
840 | .dc "mode-line-should-standout" "(variable)" | |
841 | If set, the mode line will be printed in reverse video, if your | |
842 | terminal supports it. The default for this variable is "off". | |
843 | .dc "name-keyboard-macro" "Not Bound" | |
844 | This copies the keyboard macro and gives it a name freeing up the | |
845 | keyboard macro so you can define some more. Keyboard macros with | |
846 | their own names can be bound to keys just like built in commands | |
847 | can. See the | |
848 | .IQ read-macros-file-file | |
849 | and | |
850 | .IQ write-macros-to-file | |
851 | commands. | |
852 | .dc "newline" "Return" | |
853 | This divides the current line at point moving all the text to the | |
854 | right of point down onto the newly created line. Point moves down to | |
855 | the beginning of the new line. | |
856 | .dc "newline-and-backup" "C-O" | |
857 | This divides the current line at point moving all the text to the | |
858 | right of point down onto the newly created line. The difference | |
859 | between this and "newline" is that point does not move down to the | |
860 | beginning of the new line. | |
861 | .dc "newline-and-indent" "LineFeed" | |
862 | This behaves the same was as Return does when in Auto Indent mode. | |
863 | This makes Auto Indent mode obsolete but it remains in the name of | |
864 | backward compatibility. | |
865 | .dc "next-error" "C-X C-N" | |
866 | This moves to the next error in the list of errors that were parsed | |
867 | with | |
868 | .IQ parse-errors | |
869 | or | |
870 | .IQ parse-special-errors. | |
871 | In one window the list | |
872 | of errors is shown with the current one always at the top. In another | |
873 | window is the file that contains the error. Point is positioned in | |
874 | this window on the line where the error occurred. | |
875 | .dc "next-line" "C-N" | |
876 | This moves down to the next line. | |
877 | .dc "next-page" "C-V" | |
878 | This displays the next page of the buffer by taking the bottom line of | |
879 | the window and redrawing the window with it at the top. If there isn't | |
880 | another page in the buffer \s-2JOVE\s0 rings the bell. If a numeric argument | |
881 | is supplied the screen is scrolled up that many lines; if the argument | |
882 | is negative the screen is scrolled down. | |
883 | .dc "next-window" "C-X N" | |
884 | This moves into the next window. Windows live in a circular list so | |
885 | when you're in the bottom window and you try to move to the next one | |
886 | you are moved to the top window. It is an error to use this command | |
887 | with only one window. | |
888 | .dc "number-lines-in-window" "Not Bound" | |
889 | This displays the line numbers for each line in the buffer being | |
890 | displayed. The number isn't actually part of the text; it's just | |
891 | printed before the actual buffer line is. To turn this off you run | |
892 | the command again; it toggles. | |
893 | .dc "over-write-mode" "Not Bound" | |
894 | This turns Over Write mode on (or off if it's currently on) in the selected | |
895 | buffer. When on, this mode changes the way the self-inserting characters | |
896 | work. Instead of inserting themselves and pushing the rest of the line over | |
897 | to the right, they replace or over-write the existing character. Also, | |
898 | Rubout replaces the character before point with a space instead of deleting | |
899 | it. When Over Write mode is on "OvrWt" is displayed on the mode line. | |
900 | .dc "page-next-window" "ESC C-V" | |
901 | This displays the next page in the next window. This is exactly the | |
902 | same as "C-X N C-V C-X P". | |
903 | .dc "paren-flash-delay" "(variable)" | |
904 | How long, in tenths of seconds, \s-2JOVE\s0 should pause on a matching | |
905 | parenthesis in | |
906 | .IQ Show Match | |
907 | mode. The default is 5. | |
908 | .dc "parse-errors" "Not Bound" | |
909 | This takes the list of C compilation errors (or output from another program | |
910 | in the same format) in the current buffer and parses them for use with the | |
911 | .IQ next-error | |
912 | and | |
913 | .IQ previous-error | |
914 | and | |
915 | .IQ current-error | |
916 | commands. | |
917 | This is a very useful tool and helps with compiling C programs and when used | |
918 | in conjunction with the "grep" UNIX command very helpful in making changes | |
919 | to a bunch of files. This command understands errors produced by cc, cpp, | |
920 | and lint; plus any other program with the same format (e.g., "grep -n"). | |
921 | \s-2JOVE\s0 visits each file that has an error and remembers each line that | |
922 | contains an error. It doesn't matter if later you insert or delete | |
923 | some lines in the buffers containing errors; \s-2JOVE\s0 remembers where | |
924 | they are regardless. | |
925 | .IQ next-error | |
926 | is automatically executed after one | |
927 | of the parse commands, so you end up at the first error. | |
928 | .dc "parse-special-errors" "Not Bound" | |
929 | This parses errors in an unknown format. Error parsing works with | |
930 | regular expression search strings with \\('s around the the file name | |
931 | and the line number. So, you can use | |
932 | .IQ parse-special-errors | |
933 | to parse | |
934 | lines that are in a slightly different format by typing in your own | |
935 | search string. If you don't know how to use regular expressions you | |
936 | can't use this command. | |
937 | .dc "parse-spelling-errors-in-buffer" "Not Bound" | |
938 | This parses a list of words in the current buffer and looks them up in | |
939 | another buffer that you specify. This will probably go away soon. | |
940 | .dc "pause-jove" "ESC S" | |
941 | This stops \s-2JOVE\s0 and returns control to the parent shell. This | |
942 | only works for users using the C-shell, and on systems that have the | |
943 | job control facility. To return to \s-2JOVE\s0 you type "fg" to the C-shell. | |
944 | .dc "physical-tabstop" "(variable)" | |
945 | How many spaces your terminal prints when it prints a tab character. | |
946 | .dc "pop-mark" "Not Bound" | |
947 | This gets executed when you run | |
948 | .IQ set-mark | |
949 | with a numeric argument. | |
950 | \s-2JOVE\s0 remembers the last 16 marks and you use | |
951 | .IQ pop-mark | |
952 | to go | |
953 | backward through the ring of marks. If you execute " | |
954 | .IQ pop-mark | |
955 | enough | |
956 | times you will eventually get back to where you started. | |
957 | .dc "popd" "Not Bound" | |
958 | This pops one entry off the directory stack. Entries are pushed with | |
959 | the | |
960 | .IQ pushd | |
961 | command. The names were stolen from the C-shell and the | |
962 | behavior is the same. | |
963 | .dc "previous-error" "C-X C-P" | |
964 | This is the same as | |
965 | .IQ next-error | |
966 | except it goes to the previous error. | |
967 | See | |
968 | .IQ next-error | |
969 | for documentation. | |
970 | .dc "previous-line" "C-P" | |
971 | This moves up to the previous line. | |
972 | .dc "previous-page" "ESC V" | |
973 | This displays the previous page of the current buffer by taking the top | |
974 | line and redrawing the window with it at the bottom. If a numeric | |
975 | argument is supplied the screen is scrolled down that many lines; if | |
976 | the argument is negative the screen is scrolled up. | |
977 | .dc "previous-window" "C-X P and C-X O" | |
978 | This moves into the next window. Windows live in a circular list so | |
979 | when you're in the top window and you try to move to the previous one | |
980 | you are moved to the bottom window. It is an error to use this command | |
981 | with only one window. | |
982 | .dc "print" "Not Bound" | |
983 | This prints the value of a \s-2JOVE\s0 variable. | |
984 | .dc "print-message" "Not Bound" | |
985 | This command prompts for a message, and then prints it on the bottom | |
986 | line where \s-2JOVE\s0 messages are printed. | |
987 | .dc "process-bind-to-key" "Not Bound" | |
988 | This command is identical to bind-to-key, except that it only affects | |
989 | your bindings when you are in a buffer attached to a process. When | |
990 | you enter the process buffer, any keys bound with this command will | |
991 | automatically take their new values. When you switch to a non-process | |
992 | buffer, the old bindings for those keys will be restored. For example, | |
993 | you might want to execute | |
994 | .DS I | |
995 | process-bind-to-key stop-process ^Z | |
996 | process-bind-to-key interrupt-process ^C | |
997 | .DE | |
998 | Then, when you start up an interactive process and switch into that | |
999 | buffer, C-Z will execute stop-process and C-C will execute interrupt- | |
1000 | process. When you switch back to a non-process buffer, C-Z will go | |
1001 | back to executing scroll-up (or whatever you have it bound to). | |
1002 | .dc "process-newline" "Return" | |
1003 | This this only gets executed when in a buffer that is attached to an | |
1004 | interactive-process. \s-2JOVE\s0 does two different things depending on where | |
1005 | you are when you hit Return. When you're at the end of the I-Process | |
1006 | buffer this does what Return normally does, except it also makes the | |
1007 | line available to the process. When point is positioned at some other | |
1008 | position that line is copied to the end of the buffer (with the prompt | |
1009 | stripped) and point is moved there with it, so you can then edit that | |
1010 | line before sending it to the process. This command | |
1011 | .IQ must | |
1012 | be bound | |
1013 | to the key you usually use to enter shell commands (Return), or else | |
1014 | you won't be able to enter any. | |
1015 | .dc "process-prompt" (variable) | |
1016 | What a prompt looks like from the i-shell and i-shell-command | |
1017 | processes. The default is "% ", the default C-shell prompt. This is | |
1018 | actually a regular expression search string. So you can set it to be | |
1019 | more than one thing at once using the \\| operator. For instance, for | |
1020 | LISP hackers, the prompt can be | |
1021 | .DS | |
1022 | "% \\|-> \\|<[0-9]>: ". | |
1023 | .DE | |
1024 | .dc "push-shell" "Not Bound" | |
1025 | This spawns a child shell and relinquishes control to it. This works | |
1026 | on any version of UNIX, but this isn't as good as | |
1027 | .IQ pause-jove | |
1028 | because | |
1029 | it takes time to start up the new shell and you get a brand new | |
1030 | environment every time. To return to \s-2JOVE\s0 you type "C-D". | |
1031 | .dc "pushd" "Not Bound" | |
1032 | This pushes a directory onto the directory stack and cd's into it. It | |
1033 | asks for the directory name but if you don't specify one it switches | |
1034 | the top two entries no the stack. It purposely behaves the same as | |
1035 | C-shell's | |
1036 | .IQ pushd. | |
1037 | .dc "pwd" "Not Bound" | |
1038 | This prints the working directory. | |
1039 | .dc "quadruple-numeric-argument" "C-U" | |
1040 | This multiplies the numeric argument by 4. So, "C-U C-F" means | |
1041 | forward 4 characters and "C-U C-U C-N" means down 16 lines. | |
1042 | .dc "query-replace-string" "ESC Q" | |
1043 | This replaces the occurrences of a specified string with a specified | |
1044 | replacement string. When an occurrence is found point is moved to it | |
1045 | and then \s-2JOVE\s0 asks what to do. The options are: | |
1046 | .DS I | |
1047 | .ta \w'Rubout111'u | |
1048 | Space to replace this occurrence and go on to the next one. | |
1049 | Period to replace this occurrence and then stop. | |
1050 | Rubout to skip this occurrence and go on to the next one. | |
1051 | C-R to enter a recursive edit. This lets you temporarily | |
1052 | suspend the replace, do some editing, and then return | |
1053 | to continue where you left off. To continue with the | |
1054 | Query Replace type "C-X C-C" as if you were trying to | |
1055 | exit \s-2JOVE\s0. Normally you would but when you are in a | |
1056 | recursive edit all it does is exit that recursive | |
1057 | editing level. | |
1058 | C-W to delete the matched string and then enter a recursive | |
1059 | edit. | |
1060 | U to undo the last replacement. | |
1061 | P or ! to go ahead and replace the remaining occurrences without | |
1062 | asking. | |
1063 | Return to stop the Query Replace. | |
1064 | .DE | |
1065 | The search for occurrences starts at point and goes to the end of the | |
1066 | buffer, so to replace in the entire buffer you must first go to the | |
1067 | beginning. | |
1068 | .dc "quit-process" "Not Bound" | |
1069 | This is the same as typing "C-\\" (the Quit character) to a normal UNIX | |
1070 | process, except it sends it to the current process in \s-2JOVE\s0. This is | |
1071 | only for versions of \s-2JOVE\s0 that have the interactive processes feature. | |
1072 | This only works when you are inside a buffer that's attached to a | |
1073 | process. | |
1074 | .dc "quoted-insert" "C-Q" | |
1075 | This lets you insert characters that normally would be executed as | |
1076 | other \s-2JOVE\s0 commands. For example, to insert "C-F" you type "C-Q C-F". | |
1077 | .dc "read-word-abbrev-file" "Not Bound" | |
1078 | This reads a specified file that contains a bunch of abbreviation | |
1079 | definitions, and makes those abbreviations available. If the selected | |
1080 | buffer is not already in Word Abbrev mode this command puts it in | |
1081 | that mode. | |
1082 | .dc "read-macros-from-file" "Not Bound" | |
1083 | This reads the specified file that contains a bunch of macro | |
1084 | definitions, and defines all the macros that were currently defined | |
1085 | when the file was created. See | |
1086 | .IQ write-macros-to-file | |
1087 | to see how to | |
1088 | save macros. | |
1089 | .dc "redraw-display" "C-L" | |
1090 | This centers the line containing point in the window. If that line is | |
1091 | already in the middle the window is first cleared and then redrawn. | |
1092 | If a numeric argument is supplied, the line is positioned at that | |
1093 | offset from the top of the window. For example, "ESC 0 C-L" positions | |
1094 | the line containing point at the top of the window. | |
1095 | .dc "recursive-edit" "Not Bound" | |
1096 | This enters a recursive editing level. This isn't really very | |
1097 | useful. I don't know why it's available for public use. I think I'll | |
1098 | delete it some day. | |
1099 | .dc "rename-buffer" "Not Bound" | |
1100 | This lets you rename the current buffer. | |
1101 | .dc "replace-in-region" "Not Bound" | |
1102 | This is the same as | |
1103 | .IQ replace-string | |
1104 | except that it is restricted | |
1105 | to occurrences between Point and Mark. | |
1106 | .dc "replace-string" "ESC R" | |
1107 | This replaces all occurrences of a specified string with a specified | |
1108 | replacement string. This is just like | |
1109 | .IQ query-replace-string | |
1110 | except | |
1111 | it replaces without asking. | |
1112 | .dc "right-margin" "(variable)" | |
1113 | Where the right margin is for | |
1114 | .IQ "Auto Fill" | |
1115 | mode and the | |
1116 | .IQ justify-paragraph | |
1117 | and | |
1118 | .IQ justify-region | |
1119 | commands. The default is 78. | |
1120 | .dc "right-margin-here" "Not Bound" | |
1121 | This sets the | |
1122 | .IQ right-margin | |
1123 | variable to the current position of | |
1124 | point. This is an easy way to say, "Make the right margin begin here," | |
1125 | without having to count the number of spaces over it actually is. | |
1126 | .dc "save-file" "C-X C-S" | |
1127 | This saves the current buffer to the associated file. This makes your | |
1128 | changes permanent so you should be sure you really want to. If the | |
1129 | buffer has not been modified | |
1130 | .IQ save-file | |
1131 | refuses to do the save. If | |
1132 | you really do want to write the file you can use "C-X C-W" which | |
1133 | executes | |
1134 | .IQ write-file. | |
1135 | .dc "scroll-down" "ESC Z" | |
1136 | This scrolls the screen one line down. If the line containing point | |
1137 | moves past the bottom of the window point is moved up to the center of | |
1138 | the window. If a numeric argument is supplied that many lines are | |
1139 | scrolled; if the argument is negative the screen is scrolled up | |
1140 | instead. | |
1141 | .dc "scroll-step" "(variable)" | |
1142 | How many lines should be scrolled if the | |
1143 | .IQ previous-line | |
1144 | or | |
1145 | .IQ next-line | |
1146 | commands move you off the top or bottom of the screen. You | |
1147 | may wish to decrease this variable if you are on a slow terminal. | |
1148 | .dc "scroll-up" "C-Z" | |
1149 | This scrolls the screen one line up. If the line containing point | |
1150 | moves past the top of the window point is moved down to the center of | |
1151 | the window. If a numeric argument is supplied that many lines are | |
1152 | scrolled; if the argument is negative the screen is scrolled down | |
1153 | instead. | |
1154 | .dc "search-exit-char" "(variable)" | |
1155 | Set this to the character you want to use to exit incremental search. | |
1156 | The default is Newline, which makes i-search compatible with normal | |
1157 | string search. | |
1158 | .dc "search-forward" "C-S" | |
1159 | This searches forward for a specified search string and positions | |
1160 | point at the end of the string if it's found. If the string is not | |
1161 | found point remains unchanged. This searches from point to the end of | |
1162 | the buffer, so any matches before point will be missed. | |
1163 | .dc "search-reverse" "C-R" | |
1164 | This searches backward for a specified search string and positions | |
1165 | point at the beginning if the string if it's found. If the string is | |
1166 | not found point remains unchanged. This searches from point to the | |
1167 | beginning of the buffer, so any matches after point will be missed. | |
1168 | .dc "select-buffer" "C-X B" | |
1169 | This selects a new or already existing buffer making it the current | |
1170 | one. You can type either the buffer name or number. If you type in | |
1171 | the name you need only type the name until it is unambiguous, at which | |
1172 | point typing Escape or Space will complete it for you. If you want to | |
1173 | create a new buffer you can type Return instead of Space, and a new | |
1174 | empty buffer will be created. | |
1175 | .dc "self-insert" "Most Printing Characters" | |
1176 | This inserts the character that invoked it into the buffer at point. | |
1177 | Initially all but a few of the printing characters are bound to | |
1178 | .IQ self-insert. | |
1179 | .dc "send-typeout-to-buffer" "(variable)" | |
1180 | When this is set \s-2JOVE\s0 will send output that normally overwrites the | |
1181 | screen (temporarily) to a buffer instead. This affects commands like | |
1182 | .IQ list-buffers, | |
1183 | .IQ list-processes, | |
1184 | and other commands that use command | |
1185 | completion. The default value is "off". | |
1186 | .dc "set" "Not Bound" | |
1187 | This gives a specified variable a new value. Occasionally you'll see | |
1188 | lines like "set this variable to that value to do this". Well, you | |
1189 | use the | |
1190 | .IQ set | |
1191 | command to do that. | |
1192 | .dc "set-mark" "C-@" | |
1193 | This sets the mark at the current position in the buffer. It prints | |
1194 | the message "Point pushed" on the message line. It says that instead | |
1195 | of "Mark set" because when you set the mark the previous mark is still | |
1196 | remembered on a ring of 16 marks. So "Point pushed" means point is | |
1197 | pushed onto the ring of marks and becomes the value of "the mark". | |
1198 | To go through the ring of marks you type "C-U C-@", or execute the | |
1199 | .IQ pop-mark | |
1200 | command. If you type this enough times you will get back | |
1201 | to where you started. | |
1202 | .dc "shell" "(variable)" | |
1203 | The shell to be used with all the shell commands command. If your SHELL | |
1204 | environment variable is set, it is used as the value of | |
1205 | .IQ shell; | |
1206 | otherwise "/bin/csh" is the default. | |
1207 | .dc "shell-command" "C-X !" | |
1208 | This runs a UNIX command and places the output from that command in a | |
1209 | buffer. \s-2JOVE\s0 creates a buffer that matches the name of the command | |
1210 | you specify and then attaches that buffer to a window. So, when you | |
1211 | have only one window running this command will cause \s-2JOVE\s0 to split the | |
1212 | window and attach the new buffer to that window. Otherwise, \s-2JOVE\s0 | |
1213 | finds the most convenient of the available windows and uses that one | |
1214 | instead. If the buffer already exists it is first emptied, except that if | |
1215 | it's holding a file, not some output from a previous command, \s-2JOVE\s0 | |
1216 | prints an error message and refuses to execute the command. If you | |
1217 | really want to execute the command you should delete that buffer | |
1218 | (saving it first, if you like) or use | |
1219 | .IQ shell-command-to-buffer, | |
1220 | and | |
1221 | try again. | |
1222 | .dc "shell-command-to-buffer" "Not Bound" | |
1223 | This is just like | |
1224 | .IQ shell-command | |
1225 | except it lets you specify the | |
1226 | buffer to use instead of \s-2JOVE\s0. | |
1227 | .dc "shell-flags" "(variable)" | |
1228 | This defines the flags that are passed to shell commands. The default is | |
1229 | "-c". See the | |
1230 | .IQ shell | |
1231 | variable to change the default shell. | |
1232 | .dc "show-match-mode" "Not Bound" | |
1233 | This turns on Show Match mode (or off if it's currently on) in the | |
1234 | selected buffer. This changes "}" and ")" so that when they are typed | |
1235 | the are inserted as usual, and then the cursor flashes back to the | |
1236 | matching "{" or "(" (depending on what was typed) for about half a | |
1237 | second, and then goes back to just after the "}" or ")" that invoked | |
1238 | the command. This is useful for typing in complicated expressions in | |
1239 | a program. You can change how long the cursor sits on the matching | |
1240 | paren by setting the "paren-flash-delay" variable in tenths of a | |
1241 | second. If the matching "{" or "(" isn't visible nothing happens. | |
1242 | .dc "shrink-window" "Not Bound" | |
1243 | This makes the current window one line shorter, if possible. Windows | |
1244 | must be at least 2 lines high, one for the text and the other for the | |
1245 | mode line. | |
1246 | .dc "source" "Not Bound" | |
1247 | This reads a bunch of \s-2JOVE\s0 commands from a file. The format of the | |
1248 | file is the same as that in your initialization file (your ".joverc") | |
1249 | in your main directory. There should be one command per line and it | |
1250 | should be as though you typed "ESC X" while in \s-2JOVE\s0. For example, | |
1251 | here's part of my initialization file: | |
1252 | .DS I | |
1253 | bind-to-key i-search-reverse ^R | |
1254 | bind-to-key i-search-forward ^S | |
1255 | bind-to-key pause-jove ^[S | |
1256 | .DE | |
1257 | What they do is make "C-R" call the | |
1258 | .IQ i-search-reverse | |
1259 | command and | |
1260 | "C-S" call | |
1261 | .IQ i-search-forward | |
1262 | and "ESC S" call | |
1263 | .IQ pause-jove. | |
1264 | .dc "spell-buffer" "Not Bound" | |
1265 | This runs the current buffer through the UNIX | |
1266 | .IQ spell | |
1267 | program and places | |
1268 | the output in buffer "Spell". Then \s-2JOVE\s0 lets you edit the list of | |
1269 | words, expecting you to delete the ones that you don't care about, i.e., the | |
1270 | ones you know are spelled correctly. Then the | |
1271 | .IQ parse-spelling-errors-in-buffer | |
1272 | command comes along and finds all the | |
1273 | misspelled words and sets things up so the error commands work. | |
1274 | .dc "split-current-window" "C-X 2" | |
1275 | This splits the current window into two equal parts (providing the | |
1276 | resulting windows would be big enough) and displays the selected | |
1277 | buffer in both windows. Use "C-X 1" to go back to 1 window mode. | |
1278 | .dc "start-remembering" "C-X (" | |
1279 | This starts remembering your key strokes in the Keyboard macro. To | |
1280 | stop remembering you type "C-X )". Because of a bug in \s-2JOVE\s0 you can't | |
1281 | stop remembering by typing "ESC X stop-remembering"; | |
1282 | .IQ stop-remembering | |
1283 | must be bound to "C-X )" in order to make things work correctly. To | |
1284 | execute the remembered key strokes you type "C-X E" which runs the | |
1285 | .IQ execute-keyboard-macro | |
1286 | command. | |
1287 | Sometimes you may want a macro to accept different input each time it runs. | |
1288 | To see how to do this, see the | |
1289 | .IQ make-macro-interactive | |
1290 | command. | |
1291 | .dc "stop-process" "Not Bound" | |
1292 | This sends a stop signal (C-Z, for most people) to the current process. | |
1293 | It only works if you have the interactive process feature, and you are | |
1294 | in a buffer attached to a process. | |
1295 | .dc "stop-remembering" "C-X )" | |
1296 | This stop the definition of the keyboard macro. Because of a bug in | |
1297 | \s-2JOVE\s0, this must be bound to "C-X )". Anything else will not work | |
1298 | properly. | |
1299 | .dc "string-length" "Not Bound" | |
1300 | This prints the number of characters in the string that point sits in. | |
1301 | Strings are surrounded by double quotes. \s-2JOVE\s0 knows that "\\007" is | |
1302 | considered a single character, namely "C-G", and also knows about | |
1303 | other common ones, like "\\r" (Return) and "\\n" (LineFeed). This is | |
1304 | mostly useful only for C programmers. | |
1305 | .dc "suspend-jove" "ESC S" | |
1306 | This is a synonym for | |
1307 | .IQ pause-jove. | |
1308 | .dc "sync-frequency" "(variable)" | |
1309 | The temporary files used by \s-2JOVE\s0 are forced out to disk every | |
1310 | .IQ sync-frequency | |
1311 | modifications. The default is 50, which really makes | |
1312 | good sense. Unless your system is very unstable, you probably | |
1313 | shouldn't fool with this. | |
1314 | .dc "tag-file" "(variable)" | |
1315 | This the name of the file in which \s-2JOVE\s0 should look up tag | |
1316 | definitions. The default value is "./tags". | |
1317 | .dc "text-mode" "Not Bound" | |
1318 | This sets the major mode to Text. Currently the other modes are | |
1319 | Fundamental, C and Lisp mode. | |
1320 | .dc "transpose-characters" "C-T" | |
1321 | This switches the character before point with the one after point, and | |
1322 | then moves forward one. This doesn't work at the beginning of the | |
1323 | line, and at the end of the line it switches the two characters before | |
1324 | point. Since point is moved forward, so that the character that was | |
1325 | before point is still before point, you can use "C-T" to drag a | |
1326 | character down the length of a line. This command pretty quickly | |
1327 | becomes very useful. | |
1328 | .dc "transpose-lines" "C-X C-T" | |
1329 | This switches the current line with the one above it, and then moves | |
1330 | down one so that the line that was above point is still above point. | |
1331 | This, like | |
1332 | .IQ transpose-characters, | |
1333 | can be used to drag a line down a page. | |
1334 | .dc "unbind-key" "Not Bound" | |
1335 | Use this to unbind | |
1336 | .IQ any | |
1337 | key sequence. You can use this to unbind even a | |
1338 | prefix command, since this command does not use "key-map completion". For | |
1339 | example, "ESC X unbind-key ESC [" unbinds the sequence "ESC [". This is | |
1340 | useful for "turning off" something set in the system-wide ".joverc" file. | |
1341 | .dc "update-time-frequency" "(variable)" | |
1342 | How often the mode line is updated (and thus the time and load | |
1343 | average, if you display them). The default is 30 seconds. | |
1344 | .dc "use-i/d-char" "(variable)" | |
1345 | If your terminal has insert/delete character capability you can tell \s-2JOVE\s0 | |
1346 | not to use it by setting this to "off". In my opinion it is only worth using | |
1347 | insert/delete character at low baud rates. WARNING: if you set this to | |
1348 | "on" when your terminal doesn't have insert/delete character capability, | |
1349 | you will get weird (perhaps fatal) results. | |
1350 | .dc "version" "Not Bound" | |
1351 | Displays the version number of this \s-2JOVE\s0. | |
1352 | .dc "visible-bell" "(variable)" | |
1353 | Use the terminal's visible bell instead of beeping. This is set | |
1354 | automatically if your terminal has the capability. | |
1355 | .dc "visible-spaces-in-window" "Not Bound" | |
1356 | This displays an underscore character instead of each space in the | |
1357 | window and displays a greater-than followed by spaces for each tab | |
1358 | in the window. The actual text in the buffer is not changed; only | |
1359 | the screen display is affected. To turn this off you run the command | |
1360 | again; it toggles. | |
1361 | .dc "visit-file" "C-X C-V" | |
1362 | This reads a specified file into the current buffer replacing the old | |
1363 | text. If the buffer needs saving \s-2JOVE\s0 will offer to save it for you. | |
1364 | Sometimes you use this to start over, say if you make lots of changes | |
1365 | and then change your mind. If that's the case you don't want \s-2JOVE\s0 to | |
1366 | save your buffer and you answer "NO" to the question. | |
1367 | .dc "window-find" "C-X 4" | |
1368 | This lets you select another buffer in another window three | |
1369 | different ways. This waits for another character which can be one of | |
1370 | the following: | |
1371 | .DS I | |
1372 | .ta .5i 1i 1.5i | |
1373 | T Finds a tag in the other window. | |
1374 | F Finds a file in the other window. | |
1375 | B Selects a buffer in the other window. | |
1376 | .DE | |
1377 | This is just a convenient short hand for "C-X 2" (or "C-X O" if there are | |
1378 | already two windows) followed by the appropriate sequence for invoking each | |
1379 | command. With this, though, there isn't the extra overhead of having to | |
1380 | redisplay. In addition, you don't have to decide whether to type "C-X 2" or | |
1381 | "C-X O" since "C-X 4" does the right thing. | |
1382 | .dc "word-abbrev-mode" "Not Bound" | |
1383 | This turns on Word Abbrev mode (or off if it's currently on) in the | |
1384 | selected buffer. Word Abbrev mode lets you specify a word (an | |
1385 | abbreviation) and a phrase with which \s-2JOVE\s0 should substitute the | |
1386 | abbreviation. You can use this to define words to expand into long | |
1387 | phrases, e.g., "jove" can expand into "Jonathan's Own Version of | |
1388 | Emacs"; another common use is defining words that you often misspell | |
1389 | in the same way, e.g., "thier" => "their" or "teh" => "the". See | |
1390 | the information on the | |
1391 | .IQ auto-case-abbrev | |
1392 | variable. | |
1393 | .sp 1 | |
1394 | There are two kinds of abbreviations: mode specific and global. If | |
1395 | you define a Mode specific abbreviation in C mode, it will expand only | |
1396 | in buffers that are in C mode. This is so you can have the same | |
1397 | abbreviation expand to different things depending on your context. | |
1398 | Global abbreviations expand regardless of the major mode of the | |
1399 | buffer. The way it works is this: \s-2JOVE\s0 looks first in the mode | |
1400 | specific table, and then in the global table. Whichever it finds it | |
1401 | in first is the one that's used in the expansion. If it doesn't find | |
1402 | the word it is left untouched. | |
1403 | \s-2JOVE\s0 tries to expand words as they are typed, when you type a | |
1404 | punctuation character or Space or Return. If you are in Auto Fill | |
1405 | mode the expansion will be filled as if you typed it yourself. | |
1406 | .dc "wrap-search" "(variable)" | |
1407 | If set, searches will "wrap around" the ends of the buffer instead | |
1408 | of stopping at the bottom or top. The default is "off". | |
1409 | .dc "write-files-on-make" "(variable)" | |
1410 | When set, all modified files will be written out before calling | |
1411 | make when the | |
1412 | .IQ compile-it | |
1413 | command is executed. The default is "on". | |
1414 | .dc "write-word-abbrev-file" "Not Bound" | |
1415 | This writes the currently defined abbreviations to a specified file. | |
1416 | They can be read back in and automatically defined with | |
1417 | .IQ read-word-abbrev-file. | |
1418 | .dc "write-file" "C-X C-W" | |
1419 | This saves the current buffer to a specified file, and then makes that | |
1420 | file the default file name for this buffer. If you specify a file | |
1421 | that already exists you are asked to confirm over-writing it. | |
1422 | .dc "write-macros-to-file" "Not Bound" | |
1423 | This writes the currently defined macros to a specified file. The | |
1424 | macros can be read back in with | |
1425 | .IQ read-macros-from-file | |
1426 | so you can | |
1427 | define macros and still use them in other instantiations of \s-2JOVE\s0. | |
1428 | .dc "write-modified-files" "C-X C-M" | |
1429 | This saves all the buffers that need saving. If you supply a numeric | |
1430 | argument it asks for each buffer whether you really want to save it. | |
1431 | .dc "write-region" "Not Bound" | |
1432 | This writes the text in the region to a specified file. If the file | |
1433 | already exists you are asked to confirm over-writing it. | |
1434 | .dc "yank" "C-Y" | |
1435 | This undoes the last kill command. That is, it inserts the killed | |
1436 | text at point. When you do multiple kill commands in a row, they are | |
1437 | merged so that yanking them back with "C\-Y" yanks back all of them. | |
1438 | .dc "yank-pop" "ESC Y" | |
1439 | This yanks back previous killed text. \s-2JOVE\s0 has a kill ring on which | |
1440 | the last 10 kills are stored. | |
1441 | .IQ Yank | |
1442 | yanks a copy of the text at the | |
1443 | front of the ring. If you want one of the last ten kills you use "ESC | |
1444 | Y" which rotates the ring so another different entry is now at the | |
1445 | front. You can use "ESC Y" only immediately following a "C-Y" or | |
1446 | another "ESC Y". If you supply a negative numeric argument the ring | |
1447 | is rotated the other way. If you use this command enough times in a | |
1448 | row you will eventually get back to where you started. Experiment | |
1449 | with this. It's extremely useful. |