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