43BSDReno/contrib/jove/doc/cmds.doc - annotate

Return to cmds.doc CVS log

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

Annotation of 43BSDReno/contrib/jove/doc/cmds.doc, revision 1.1.1.1

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

unix.superglobalmegacorp.com

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