![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jove.5 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove / doc|
Return to jove.5 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove / doc |
1.1 root 1: .dc "make-backup-files" "(variable)"
2: If this variable is set, then whenever \s-2JOVE\s0 writes out a file, it will
3: move the previous version of the file (if there was one) to "#filename".
4: This is often convenient if you save a file by accident. The default
5: value of this variable is "off".
6: .IQ Note:
7: this is an optional part of
8: \s-2JOVE\s0, and your guru may not have it enabled, so it may not work.
9: .dc "make-buffer-unmodified" "ESC ~"
10: This makes \s-2JOVE\s0 think the selected buffer hasn't been changed even if
11: it has. Use this when you accidentally change the buffer but don't
12: want it considered changed. Watch the mode line to see the * disappear
13: when you use this command.
14: .dc "make-keymap" "Not Bound"
15: This creates an empty keymap with a name you supply. That name can be
16: used to reference the keymap in other commands, such as
17: bind-keymap-to-key.
18: .dc "make-macro-interactive" "Not Bound"
19: This command is meaningful only while you are defining a keyboard macro,
20: and when you are in the minibuffer. Ordinarily, when a command in a macro
21: definition requires a trailing text argument (file name, search string,
22: etc.), the argument you supply becomes part of the macro definition. If
23: you want to be able to supply a different argument each time the macro is
24: used, then while you are defining it, you should give the
25: make-macro-interactive command just before typing the argument which will
26: be used during the definition process. Note: you must bind this command
27: to a key in order to use it; you can't say "ESC X make-macro-interactive".
28: .dc "mark-threshold" "(variable)"
29: This variable contains the number of lines point may move by before
30: the mark is set. If, in a search or something, point moves by more
31: than this many lines, the mark is set so that you may return easily.
32: The default value of this variable is 22 (one screenful, on most
33: terminals).
34: .dc "marks-should-float" "(variable)"
35: When this variable is "off", the position of a mark is remembered as a line
36: number within the buffer and a character number within the line. If you add
37: or delete text before the mark, it will no longer point to the text you
38: marked originally because that text is no longer at the same line and
39: character number. When this variable is "on", the position of a mark is
40: adjusted to compensate for each insertion and deletion. This makes marks
41: much more sensible to use, at the cost of slowing down insertion and
42: deletion somewhat. The default value is "on".
43: .dc "match-regular-expressions" "(variable)"
44: When set, \s-2JOVE\s0 will match regular expressions in search patterns.
45: This makes special the characters ., *, [, ], ^, and $, and the two-character
46: sequences \e<, \e>, \e\|{, \e\|} and \e\||.
47: See the
48: .IQ ed(1)
49: manual page, the tutorial "Advanced Editing in
50: .UX
51: ", and the section above "Searching with Regular Expressions"
52: for more information.
53: .dc "meta-key" "(variable)"
54: You should set this variable to "on" if your terminal has a real Meta key.
55: If your terminal has such a key, then a key sequence like ESC Y can be
56: entered by holding down Meta and typing Y. NOTE: In some systems, this
57: disables interrupting noninteractive shell commands.
58: .dc "mode-line" "(variable)"
59: The format of the mode line can be determined by setting this variable.
60: The items in the line are specified using a format similar to that used by printf(3),
61: with the special things being marked as "%x". Digits may be used between the
62: '%' and the 'x' to mean repeat that many times.
63: \&'x' may be:
64: .DS I
65: .ta .5i 1i 1.5i
66: C check for new mail, and displays "[New mail]" if there
67: is any (see also the mail-check-interval and disable-biff
68: variables)
69: F the current file name, with leading path stripped
70: M the current list of major and minor modes
71: b the current buffer name
72: c the fill character (-)
73: d the current directory
74: e extra space in modeline is distributed evenly
75: among the place %e is used (used for justifying,
76: separating, or centering parts of the modeline)
77: f the current file name
78: l the current load average (updated automatically)
79: mxy x, when the buffer is modified or y, when not
80: n the current buffer number
81: p interactive process status for process windows
82: s space, but only if previous character is not a space
83: t the current time (updated automatically)
84: w a '>' for windows which are scrolled left
85: [ ] the square brackets printed when in a recursive edit
86: ( ) items enclosed in %( ... %) will only be printed on
87: the bottom mode line, rather than copied when the
88: window is split
89: .DE
90: In addition, any other character is simply copied into the mode line.
91: Characters may be escaped with a backslash. To get a feel for all
92: this, try typing "ESC X print mode-line" and compare the result with
93: your current mode line.
94: .dc "mode-line-color" "(variable)"
95: This specifies the color of the modeline (PC version only). Its default
96: value is 0, and in that case it is drawn in reverse video. If it has any
97: other value, this value is used as the attribute in the Bios calls.
98: .dc "mode-line-should-standout" "(variable)"
99: If set, the mode line will be printed in reverse video, if your
100: terminal supports it. The default for this variable is "off".
101: .dc "name-kbd-macro" "Not Bound"
102: This copies the keyboard macro and gives it a name freeing up the
103: keyboard macro so you can define some more. Keyboard macros with
104: their own names can be bound to keys just like built in commands
105: can. See the
106: .IQ define-macro,
107: .IQ source
108: and
109: .IQ write-macros-to-file
110: commands.
111: .dc "newline" "Return"
112: This divides the current line at point moving all the text to the
113: right of point down onto the newly created line. Point moves down to
114: the beginning of the new line.
115: .dc "newline-and-backup" "C-O"
116: This divides the current line at point moving all the text to the
117: right of point down onto the newly created line. The difference
118: between this and "newline" is that point does not move down to the
119: beginning of the new line.
120: .dc "newline-and-indent" "LineFeed"
121: This behaves the same was as Return does when in Auto Indent mode.
122: This makes Auto Indent mode obsolete but it remains in the name of
123: backward compatibility.
124: .dc "next-error" "C-X C-N"
125: This moves to the next error in the list of errors that were parsed
126: with
127: .IQ parse-errors.
128: In one window the list of errors is shown with the current one always at
129: the top. In another window is the file that contains the error. Point
130: is positioned in this window on the line where the error occurred.
131: .dc "next-line" "C-N"
132: This moves down to the next line.
133: .dc "next-page" "C-V"
134: This displays the next page of the buffer by taking the bottom line of
135: the window and redrawing the window with it at the top. If there isn't
136: another page in the buffer \s-2JOVE\s0 rings the bell. If a numeric argument
137: is supplied the screen is scrolled up that many lines; if the argument
138: is negative the screen is scrolled down.
139: .dc "next-window" "C-X N"
140: This moves into the next window. Windows live in a circular list so
141: when you're in the bottom window and you try to move to the next one
142: you are moved to the top window. It is an error to use this command
143: with only one window.
144: .dc "number-lines-in-window" "Not Bound"
145: This displays the line numbers for each line in the buffer being
146: displayed. The number isn't actually part of the text; it's just
147: printed before the actual buffer line is. To turn this off you run
148: the command again; it toggles.
149: .dc "over-write-mode" "Not Bound"
150: This turns Over Write mode on (or off if it's currently on) in the selected
151: buffer. When on, this mode changes the way the self-inserting characters
152: work. Instead of inserting themselves and pushing the rest of the line over
153: to the right, they replace or over-write the existing character. Also,
154: Rubout replaces the character before point with a space instead of deleting
155: it. When Over Write mode is on "OvrWt" is displayed on the mode line.
156: .dc "page-next-window" "ESC C-V"
157: This displays the next page in the next window. This is exactly the
158: same as "C-X N C-V C-X P".
159: .dc "paren-flash" ") } ]"
160: This handles the C mode curly brace indentation, the Lisp mode paren
161: indentation, and the Show Match mode paren/curly brace/square bracket
162: flashing.
163: .dc "paren-flash-delay" "(variable)"
164: How long, in tenths of seconds, \s-2JOVE\s0 should pause on a matching
165: parenthesis in
166: .IQ Show Match
167: mode. The default is 5.
168: .dc "parse-errors" "Not Bound"
169: This takes the list of C compilation errors (or output from another program
170: in the same format) in the current buffer and parses them for use with the
171: .IQ next-error
172: and
173: .IQ previous-error
174: and
175: .IQ current-error
176: commands.
177: This is a very useful tool and helps with compiling C programs and when used
178: in conjunction with the "grep" UNIX command very helpful in making changes
179: to a bunch of files. This command understands errors produced by cc, cpp,
180: and lint; plus any other program with the same format (e.g., "grep -n").
181: \s-2JOVE\s0 visits each file that has an error and remembers each line that
182: contains an error. It doesn't matter if later you insert or delete
183: some lines in the buffers containing errors; \s-2JOVE\s0 remembers where
184: they are regardless.
185: .IQ current-error
186: is automatically executed after one of the parse commands, so you end up
187: at the first error. See also
188: .IQ error-format-string
189: to make it possible to parse errors of a different format.
190: .dc "parse-spelling-errors-in-buffer" "Not Bound"
191: This parses a list of words in the current buffer and looks them up in
192: another buffer that you specify. This will probably go away soon.
193: .dc "pause-jove" "ESC S"
194: This stops \s-2JOVE\s0 and returns control to the parent shell. This
195: only works for users using the C-shell, and on systems that have the
196: job control facility. To return to \s-2JOVE\s0 you type "fg" to the C-shell.
197: .dc "physical-tabstop" "(variable)"
198: How many spaces your terminal prints when it prints a tab character.
199: .dc "pop-mark" "Not Bound"
200: This gets executed when you run
201: .IQ set-mark
202: with a numeric argument.
203: \s-2JOVE\s0 remembers the last 16 marks and you use
204: .IQ pop-mark
205: to go
206: backward through the ring of marks. If you execute
207: .IQ pop-mark
208: enough
209: times you will eventually get back to where you started.
210: .dc "popd" "Not Bound"
211: This pops one entry off the directory stack. Entries are pushed with
212: the
213: .IQ pushd
214: command. The names were stolen from the C-shell and the
215: behavior is the same.
216: .dc "previous-error" "C-X C-P"
217: This is the same as
218: .IQ next-error
219: except it goes to the previous error.
220: See
221: .IQ next-error
222: for documentation.
223: .dc "previous-line" "C-P"
224: This moves up to the previous line.
225: .dc "previous-page" "ESC V"
226: This displays the previous page of the current buffer by taking the top
227: line and redrawing the window with it at the bottom. If a numeric
228: argument is supplied the screen is scrolled down that many lines; if
229: the argument is negative the screen is scrolled up.
230: .dc "previous-window" "C-X P and C-X O"
231: This moves into the next window. Windows live in a circular list so
232: when you're in the top window and you try to move to the previous one
233: you are moved to the bottom window. It is an error to use this command
234: with only one window.
235: .dc "print" "Not Bound"
236: This prints the value of a \s-2JOVE\s0 variable.
237: .dc "process-bind-keymap-to-key" "Not Bound"
238: This is just like "bind-to-key" except that it starts at the
239: process-keymap map, instead of the default mainmap.
240: .dc "process-bind-to-key" "Not Bound"
241: This command is identical to bind-to-key, except that it only affects
242: your bindings when you are in a buffer attached to a process. When
243: you enter the process buffer, any keys bound with this command will
244: automatically take their new values. When you switch to a non-process
245: buffer, the old bindings for those keys will be restored. For example,
246: you might want to execute
247: .DS I
248: process-bind-to-key stop-process ^Z
249: process-bind-to-key interrupt-process ^C
250: .DE
251: Then, when you start up an interactive process and switch into that
252: buffer, C-Z will execute stop-process and C-C will execute interrupt-
253: process. When you switch back to a non-process buffer, C-Z will go
254: back to executing scroll-up (or whatever you have it bound to).
255: .dc "process-dbx-output" "Not Bound"
256: This command only makes sense in a buffer running a shell process. If
257: you are running dbx in a window, JOVE will automatically find the file
258: you are currently stepping through and display it in another window.
259: The string DBX will appear in the modeline along with the other minor
260: modes when this feature is enabled.
261: .dc "process-newline" "Return"
262: This only gets executed when in a buffer that is attached to an
263: interactive-process. \s-2JOVE\s0 does two different things depending on where
264: you are when you hit Return. When you're at the end of the I-Process
265: buffer this does what Return normally does, except it also makes the
266: line available to the process. When point is positioned at some other
267: position that line is copied to the end of the buffer (with the prompt
268: stripped) and point is moved there with it, so you can then edit that
269: line before sending it to the process. This command
270: .IQ must
271: be bound
272: to the key you usually use to enter shell commands (Return), or else
273: you won't be able to enter any.
274: .dc "process-prompt" (variable)
275: What a prompt looks like from the shell and i-shell-command
276: processes. The default is "% ", the default C-shell prompt. This is
277: actually a regular expression search string. So you can set it to be
278: more than one thing at once using the \e| operator. For instance, for
279: LISP hackers, the prompt can be
280: .DS
281: "% \e|-> \e|<[0-9]>: ".
282: .DE
283: .dc "process-send-data-no-return" "Not Bound"
284: This is like
285: .IQ process-newline
286: except it sends everything to the process without the newline. Normally,
287: when you type return in a process buffer it sends everything you typed
288: including the Return. This command just provides a way to send data to
289: the process without having to send a newline as well.
290: .dc "push-shell" "Not Bound"
291: This spawns a child shell and relinquishes control to it. This works
292: on any version of UNIX, but this isn't as good as
293: .IQ pause-jove
294: because
295: it takes time to start up the new shell and you get a brand new
296: environment every time. To return to \s-2JOVE\s0 you type "C-D".
297: .dc "pushd" "Not Bound"
298: This pushes a directory onto the directory stack and cd's into it. It
299: asks for the directory name but if you don't specify one it switches
300: the top two entries no the stack. It purposely behaves the same as
301: C-shell's
302: .IQ pushd.
303: .dc "pwd" "Not Bound"
304: This prints the working directory.
305: .dc "query-replace-string" "ESC Q"
306: This replaces the occurrences of a specified string with a specified
307: replacement string. When an occurrence is found point is moved to it
308: and then \s-2JOVE\s0 asks what to do. The options are:
309: .DS I
310: .ta \w'Rubout111'u
311: Space to replace this occurrence and go on to the next one.
312: Period to replace this occurrence and then stop.
313: Rubout to skip this occurrence and go on to the next one.
314: C-R to enter a recursive edit. This lets you temporarily
315: suspend the replace, do some editing, and then return
316: to continue where you left off. To continue with the
317: Query Replace type "C-X C-C" as if you were trying to
318: exit \s-2JOVE\s0. Normally you would but when you are in a
319: recursive edit all it does is exit that recursive
320: editing level.
321: C-W to delete the matched string and then enter a recursive
322: edit.
323: U to undo all changes to the last modified line.
324: P or ! to go ahead and replace the remaining occurrences without
325: asking.
326: Return to stop the Query Replace.
327: .DE
328: The search for occurrences starts at point and goes to the end of the
329: buffer, so to replace in the entire buffer you must first go to the
330: beginning.
331: .dc "quit-process" "Not Bound"
332: This is the same as typing "C-\e" (the Quit character) to a normal UNIX
333: process, except it sends it to the current process in \s-2JOVE\s0. This is
334: only for versions of \s-2JOVE\s0 that have the interactive processes feature.
335: This only works when you are inside a buffer that's attached to a
336: process.
337: .dc "quoted-insert" "C-Q"
338: This lets you insert characters that normally would be executed as
339: other \s-2JOVE\s0 commands. For example, to insert "C-F" you type "C-Q C-F".
340: .dc "read-only-mode" "Not Bound"
341: Read-only-mode is a minor mode. It puts a buffer in read-only mode, so
342: that any attempts to modify the buffer fail. When a file is found, and
343: it's not got write permission, JOVE automatically puts the buffer in
344: read-only mode. This is very helpful when you are in environments which
345: use source control programs like RCS and SCCS. It prevents accidents
346: like making a bunch of changes and only THEN discovering that you haven't
347: checked the file out for making changes. This, like other minor modes,
348: toggles.
349: .dc "read-word-abbrev-file" "Not Bound"
350: This reads a specified file that contains a bunch of abbreviation
351: definitions, and makes those abbreviations available. If the selected
352: buffer is not already in Word Abbrev mode this command puts it in
353: that mode.
354: .dc "recursive-edit" "Not Bound"
355: This enters a recursive editing level. This isn't really very
356: useful. I don't know why it's available for public use. I think I'll
357: delete it some day.
358: .dc "redraw-display" "C-L"
359: This centers the line containing point in the window. If that line is
360: already in the middle the window is first cleared and then redrawn.
361: If a numeric argument is supplied, the line is positioned at that
362: offset from the top of the window. For example, "ESC 0 C-L" positions
363: the line containing point at the top of the window.
364: .dc "rename-buffer" "Not Bound"
365: This lets you rename the current buffer.
366: .dc "replace-in-region" "Not Bound"
367: This is the same as
368: .IQ replace-string
369: except that it is restricted
370: to occurrences between Point and Mark.
371: .dc "replace-string" "ESC R"
372: This replaces all occurrences of a specified string with a specified
373: replacement string. This is just like
374: .IQ query-replace-string
375: except
376: it replaces without asking.
377: .dc "right-margin" "(variable)"
378: Where the right margin is for
379: .IQ "Auto Fill"
380: mode and the
381: .IQ justify-paragraph
382: and
383: .IQ justify-region
384: commands. The default is 78.
385: .dc "right-margin-here" "Not Bound"
386: This sets the
387: .IQ right-margin
388: variable to the current position of
389: point. This is an easy way to say, "Make the right margin begin here,"
390: without having to count the number of spaces over it actually is.
391: .dc "save-file" "C-X C-S"
392: This saves the current buffer to the associated file. This makes your
393: changes permanent so you should be sure you really want to. If the
394: buffer has not been modified
395: .IQ save-file
396: refuses to do the save. If
397: you really do want to write the file you can use "C-X C-W" which
398: executes
399: .IQ write-file.
400: .dc "scroll-all-lines" "(variable)"
401: When this is turned on, the entire window will be scrolled left or right
402: when the current line scrolls. The default value is OFF, which will
403: cause \s-2JOVE\s0 to behave in the familiar way, namely to scroll only
404: the current line.
405: .dc "scroll-down" "ESC Z"
406: This scrolls the screen one line down. If the line containing point
407: moves past the bottom of the window point is moved up to the center of
408: the window. If a numeric argument is supplied that many lines are
409: scrolled; if the argument is negative the screen is scrolled up
410: instead.
411: .dc "scroll-left" "Not Bound"
412: This scrolls the text in the current window 10 character positions to the
413: left. If a numeric argument is specified then the text is scrolled that
414: number of character positions. If the variable
415: .IQ scroll-all-lines
416: is ON then
417: .IQ scroll-left
418: may actually do nothing if the scrolling would cause Point not to be
419: visible.
420: .dc "scroll-next-page" "Not Bound"
421: This continuously scrolls up screen-full lines (PC version only).
422: .dc "scroll-previous-page" "Not Bound"
423: This continuously scrolls down screen-full lines (PC version only).
424: .dc "scroll-right" "Not Bound"
425: This scrolls the text in the current window 10 character positions to the
426: right. If a numeric argument is specified then the text is scrolled that
427: number of character positions. If the variable
428: .IQ scroll-all-lines
429: is ON then
430: .IQ scroll-right
431: may actually do nothing if the scrolling would cause Point not to be
432: visible.
433: .dc "scroll-step" "(variable)"
434: How many lines should be scrolled if the
435: .IQ previous-line
436: or
437: .IQ next-line
438: commands move you off the top or bottom of the screen. You may wish to
439: decrease this variable if you are on a slow terminal. The default value
440: is 0, which means to center the current line in the window. If the value
441: is negative, the behavior is slightly different. If you move off the top
442: of the window, and
443: .IQ scroll-step
444: is, say, -5 then the new line will be displayed 5 lines from the bottom
445: of the window. If you move off the bottom of the window, the new line
446: will be positioned 5 lines from the top of the window.
447: .dc "scroll-up" "C-Z"
448: This scrolls the screen one line up. If the line containing point
449: moves past the top of the window point is moved down to the center of
450: the window. If a numeric argument is supplied that many lines are
451: scrolled; if the argument is negative the screen is scrolled down
452: instead.
453: .dc "search-exit-char" "(variable)"
454: Set this to the character you want to use to exit incremental search.
455: The default is Newline, which makes i-search compatible with normal
456: string search.
457: .dc "search-forward" "C-S"
458: This searches forward for a specified search string and positions
459: point at the end of the string if it's found. If the string is not
460: found point remains unchanged. This searches from point to the end of
461: the buffer, so any matches before point will be missed.
462: .dc "search-forward-nd" "Not Bound"
463: This is just like
464: .IQ search-forward
465: except that it doesn't assume a default search string, and it doesn't set
466: the default search string. This is useful for defining macros, when you
467: want to search for something, but you don't want it to affect the current
468: default search string.
469: .dc "search-reverse" "C-R"
470: This searches backward for a specified search string and positions
471: point at the beginning if the string if it's found. If the string is
472: not found point remains unchanged. This searches from point to the
473: beginning of the buffer, so any matches after point will be missed.
474: .dc "search-reverse-nd" "Not Bound"
475: This is just like
476: .IQ search-reverse
477: except that it doesn't assume a default search string, and it doesn't set
478: the default search string. This is useful for defining macros, when you
479: want to search for something, but you don't want it to affect the current
480: default search string.
481: .dc "select-buffer" "C-X B"
482: This selects a new or already existing buffer making it the current
483: one. You can type either the buffer name or number. If you type in
484: the name you need only type the name until it is unambiguous, at which
485: point typing Escape or Space will complete it for you. If you want to
486: create a new buffer you can type Return instead of Space, and a new
487: empty buffer will be created.
488: .dc "select-buffer-1" "<Alt>-1"
489: This selects buffer number 1, if it exists (PC version only).
490: .dc "select-buffer-2" "<Alt>-2"
491: This selects buffer number 2, if it exists (PC version only).
492: .dc "select-buffer-3" "<Alt>-3"
493: This selects buffer number 3, if it exists (PC version only).
494: .dc "select-buffer-4" "<Alt>-4"
495: This selects buffer number 4, if it exists (PC version only).
496: .dc "select-buffer-5" "<Alt>-5"
497: This selects buffer number 5, if it exists (PC version only).
498: .dc "select-buffer-6" "<Alt>-6"
499: This selects buffer number 6, if it exists (PC version only).
500: .dc "select-buffer-7" "<Alt>-7"
501: This selects buffer number 7, if it exists (PC version only).
502: .dc "select-buffer-8" "<Alt>-8"
503: This selects buffer number 8, if it exists (PC version only).
504: .dc "select-buffer-9" "<Alt>-9"
505: This selects buffer number 9, if it exists (PC version only).
506: .dc "self-insert" "Most Printing Characters"
507: This inserts the character that invoked it into the buffer at point.
508: Initially all but a few of the printing characters are bound to
509: .IQ self-insert.
510: .dc "send-typeout-to-buffer" "(variable)"
511: When this is set \s-2JOVE\s0 will send output that normally overwrites the
512: screen (temporarily) to a buffer instead. This affects commands like
513: .IQ list-buffers,
514: .IQ list-processes,
515: and commands that use completion. The default value is "off".
516: .dc "set" "Not Bound"
517: This gives a specified variable a new value. Occasionally you'll see
518: lines like "set this variable to that value to do this". Well, you
519: use the
520: .IQ set
521: command to do that.
522: .dc "set-mark" "C-@"
523: This sets the mark at the current position in the buffer. It prints
524: the message "Point pushed" on the message line. It says that instead
525: of "Mark set" because when you set the mark the previous mark is still
526: remembered on a ring of 16 marks. So "Point pushed" means point is
527: pushed onto the ring of marks and becomes the value of "the mark".
528: To go through the ring of marks you type "C-U C-@", or execute the
529: .IQ pop-mark
530: command. If you type this enough times you will get back
531: to where you started.
532: .dc "shell" "(variable)"
533: The shell to be used with all the shell commands command. If your SHELL
534: environment variable is set, it is used as the value of
535: .IQ shell;
536: otherwise "/bin/csh" is the default.
537: .dc "shell" "Not Bound"
538: This starts up an interactive shell in a window. \s-2JOVE\s0 uses
539: "*shell*" as the name of the buffer in which the interacting takes
540: place. See the manual for information on how to use interactive
541: processes.
542: .dc "shell-command" "C-X !"
543: This runs a UNIX command and places the output from that command in a
544: buffer. \s-2JOVE\s0 creates a buffer that matches the name of the command
545: you specify and then attaches that buffer to a window. So, when you
546: have only one window running this command will cause \s-2JOVE\s0 to split the
547: window and attach the new buffer to that window. Otherwise, \s-2JOVE\s0
548: finds the most convenient of the available windows and uses that one
549: instead. If the buffer already exists it is first emptied, except that if
550: it's holding a file, not some output from a previous command, \s-2JOVE\s0
551: prints an error message and refuses to execute the command. If you
552: really want to execute the command you should delete that buffer
553: (saving it first, if you like) or use
554: .IQ shell-command-to-buffer,
555: and
556: try again.
557: .dc "shell-command-no-buffer" "Not Bound"
558: This is just like
559: .IQ shell-command
560: except it just runs the command without saving the output to any buffer.
561: It will report the success of the command in the usual way.
562: .dc "shell-command-to-buffer" "Not Bound"
563: This is just like
564: .IQ shell-command
565: except it lets you specify the
566: buffer to use instead of \s-2JOVE\s0.
567: .dc "shell-command-with-typeout" "Not Bound"
568: This is just like
569: .IQ shell-command
570: except that instead of saving the output to a buffer, and displaying
571: it in a window, this just types out the output in the same way that
572: .IQ list-buffers
573: does. Actually, how this behaves depends on the value of the variable
574: .IQ send-typeout-to-buffer.
575: If it is on then shell-command-with-typeout will behave just like
576: .IQ shell-command.
577: .dc "shell-flags" "(variable)"
578: This defines the flags that are passed to shell commands. The default is
579: "-c". See the
580: .IQ shell
581: variable to change the default shell.
582: .dc "shift-region-left" "Not Bound"
583: This shifts the region left by c-indentation-increment OR by the numeric
584: argument, if one is supplied. If a negative argument is supplied the
585: region is shifted the other way.
586: .dc "shift-region-right" "Not Bound"
587: This shifts the region left by c-indentation-increment OR by the numeric
588: argument, if one is supplied. If a negative argument is supplied the
589: region is shifted the other way.
590: .dc "show-match-mode" "Not Bound"
591: This turns on Show Match mode (or off if it's currently on) in the
592: selected buffer. This changes "}", ")" and "]" so that when they are
593: typed the are inserted as usual, and then the cursor flashes back to the
594: matching "{", "(" or "[" (depending on what was typed) for about half a
595: second, and then goes back to just after the "}", ")" or "]" that invoked
596: the command. This is useful for typing in complicated expressions in a
597: program. You can change how long the cursor sits on the matching paren
598: by setting the "paren-flash-delay" variable in tenths of a second. If
599: the matching "{", "(" or "[" isn't visible, the line containing the match
600: is displayed at the bottom of the screen.
601: .dc "shrink-window" "Not Bound"
602: This makes the current window one line shorter, if possible. Windows
603: must be at least 2 lines high, one for the text and the other for the
604: mode line.
605: .dc "source" "Not Bound"
606: This reads a bunch of \s-2JOVE\s0 commands from a file. The format of the
607: file is the same as that in your initialization file (your ".joverc")
608: in your main directory. There should be one command per line and it
609: should be as though you typed "ESC X" while in \s-2JOVE\s0. For example,
610: here's part of my initialization file:
611: .DS I
612: bind-to-key i-search-reverse ^R
613: bind-to-key i-search-forward ^S
614: bind-to-key pause-jove ^[S
615: .DE
616: What they do is make "C-R" call the
617: .IQ i-search-reverse
618: command and
619: "C-S" call
620: .IQ i-search-forward
621: and "ESC S" call
622: .IQ pause-jove.
623: .dc "spell-buffer" "Not Bound"
624: This runs the current buffer through the UNIX
625: .IQ spell
626: program and places
627: the output in buffer "Spell". Then \s-2JOVE\s0 lets you edit the list of
628: words, expecting you to delete the ones that you don't care about, i.e., the
629: ones you know are spelled correctly. Then the
630: .IQ parse-spelling-errors-in-buffer
631: command comes along and finds all the
632: misspelled words and sets things up so the error commands work.
633: .dc "split-current-window" "C-X 2"
634: This splits the current window into two equal parts (providing the
635: resulting windows would be big enough) and displays the selected buffer
636: in both windows. Use "C-X 1" to go back to 1 window mode. If a numeric
637: argument is supplied, the window is split "evenly" that many times (when
638: possible).
639: .dc "start-remembering" "C-X ("
640: This is just another name for the
641: .IQ begin-kbd-macro
642: name. It is included for backward compatibility.
643: .dc "stop-process" "Not Bound"
644: This sends a stop signal (C-Z, for most people) to the current process.
645: It only works if you have the interactive process feature, and you are
646: in a buffer attached to a process.
647: .dc "stop-remembering" "C-X )"
648: This is just another name for the
649: .IQ end-kbd-macro
650: command. It is included for backward compatibility.
651: .dc "string-length" "Not Bound"
652: This prints the number of characters in the string that point sits in.
653: Strings are surrounded by double quotes. \s-2JOVE\s0 knows that "\e007" is
654: considered a single character, namely "C-G", and also knows about
655: other common ones, like "\er" (Return) and "\en" (LineFeed). This is
656: mostly useful only for C programmers.
657: .dc "suspend-jove" "ESC S"
658: This is a synonym for
659: .IQ pause-jove.
660: .dc "sync-frequency" "(variable)"
661: The temporary files used by \s-2JOVE\s0 are forced out to disk every
662: .IQ sync-frequency
663: modifications. The default is 50, which really makes
664: good sense. Unless your system is very unstable, you probably
665: shouldn't fool with this.
666: .dc "tag-file" "(variable)"
667: This the name of the file in which \s-2JOVE\s0 should look up tag
668: definitions. The default value is "./tags".
669: .dc "text-mode" "Not Bound"
670: This sets the major mode to Text. Currently the other modes are
671: Fundamental, C and Lisp mode.
672: .dc "tmp-file-pathname" "(variable)"
673: This tells JOVE where to put the tmp files, which is where JOVE stores
674: buffers internally. The default is usually in /tmp, but if you want to
675: store them somewhere else, you can set this variable. If your system
676: crashes a lot it might be a good idea to set this variable to somewhere
677: other than /tmp because the system removes all the files in /tmp upon
678: reboot, and so you would not be able to recover editor buffers using the
679: "jove -r" command.
680:
681: NOTE: In order for this to work correctly you must set this variable
682: BEFORE JOVE creates the tmp file. You can set this in your .joverc (the
683: closer to tbe beginning the better), or as soon as you start up JOVE
684: before you visit any files.
685: .dc "transpose-characters" "C-T"
686: This switches the character before point with the one after point, and
687: then moves forward one. This doesn't work at the beginning of the
688: line, and at the end of the line it switches the two characters before
689: point. Since point is moved forward, so that the character that was
690: before point is still before point, you can use "C-T" to drag a
691: character down the length of a line. This command pretty quickly
692: becomes very useful.
693: .dc "transpose-lines" "C-X C-T"
694: This switches the current line with the one above it, and then moves
695: down one so that the line that was above point is still above point.
696: This, like
697: .IQ transpose-characters,
698: can be used to drag a line down a page.
699: .dc "unbind-key" "Not Bound"
700: Use this to unbind
701: .IQ any
702: key sequence. You can use this to unbind even a
703: prefix command, since this command does not use "key-map completion". For
704: example, "ESC X unbind-key ESC [" unbinds the sequence "ESC [". This is
705: useful for "turning off" something set in the system-wide ".joverc" file.
706: .dc "update-time-frequency" "(variable)"
707: How often the mode line is updated (and thus the time and load
708: average, if you display them). The default is 30 seconds.
709: .dc "use-i/d-char" "(variable)"
710: If your terminal has insert/delete character capability you can tell \s-2JOVE\s0
711: not to use it by setting this to "off". In my opinion it is only worth using
712: insert/delete character at low baud rates. WARNING: if you set this to
713: "on" when your terminal doesn't have insert/delete character capability,
714: you will get weird (perhaps fatal) results.
715: .dc "version" "Not Bound"
716: Displays the version number of this \s-2JOVE\s0.
717: .dc "visible-bell" "(variable)"
718: Use the terminal's visible bell instead of beeping. This is set
719: automatically if your terminal has the capability.
720: .dc "visible-spaces-in-window" "Not Bound"
721: This displays an underscore character instead of each space in the
722: window and displays a greater-than followed by spaces for each tab
723: in the window. The actual text in the buffer is not changed; only
724: the screen display is affected. To turn this off you run the command
725: again; it toggles.
726: .dc "visit-file" "C-X C-V"
727: This reads a specified file into the current buffer replacing the old
728: text. If the buffer needs saving \s-2JOVE\s0 will offer to save it for you.
729: Sometimes you use this to start over, say if you make lots of changes
730: and then change your mind. If that's the case you don't want \s-2JOVE\s0 to
731: save your buffer and you answer "NO" to the question.
732: .dc "window-find" "C-X 4"
733: This lets you select another buffer in another window three
734: different ways. This waits for another character which can be one of
735: the following:
736: .DS I
737: .ta .5i 1i 1.5i
738: T Finds a tag in the other window.
739: ^T Finds the tag at point in the other window
740: F Finds a file in the other window.
741: B Selects a buffer in the other window.
742: .DE
743: This is just a convenient short hand for "C-X 2" (or "C-X O" if there are
744: already two windows) followed by the appropriate sequence for invoking each
745: command. With this, though, there isn't the extra overhead of having to
746: redisplay. In addition, you don't have to decide whether to type "C-X 2" or
747: "C-X O" since "C-X 4" does the right thing.
748: .dc "word-abbrev-mode" "Not Bound"
749: This turns on Word Abbrev mode (or off if it's currently on) in the
750: selected buffer. Word Abbrev mode lets you specify a word (an
751: abbreviation) and a phrase with which \s-2JOVE\s0 should substitute the
752: abbreviation. You can use this to define words to expand into long
753: phrases, e.g., "jove" can expand into "Jonathan's Own Version of
754: Emacs"; another common use is defining words that you often misspell
755: in the same way, e.g., "thier" => "their" or "teh" => "the". See
756: the information on the
757: .IQ auto-case-abbrev
758: variable.
759: .sp 1
760: There are two kinds of abbreviations: mode specific and global. If you
761: define a Mode specific abbreviation in C mode, it will expand only in
762: buffers that are in C mode. This is so you can have the same
763: abbreviation expand to different things depending on your context.
764: Global abbreviations expand regardless of the major mode of the buffer.
765: The way it works is this: \s-2JOVE\s0 looks first in the mode specific
766: table, and then in the global table. Whichever it finds it in first is
767: the one that's used in the expansion. If it doesn't find the word it is
768: left untouched. \s-2JOVE\s0 tries to expand words as they are typed, when
769: you type a punctuation character or Space or Return. If you are in Auto
770: Fill mode the expansion will be filled as if you typed it yourself.
771: .dc "wrap-search" "(variable)"
772: If set, searches will "wrap around" the ends of the buffer instead
773: of stopping at the bottom or top. The default is "off".
774: .dc "write-file" "C-X C-W"
775: This saves the current buffer to a specified file, and then makes that
776: file the default file name for this buffer. If you specify a file
777: that already exists you are asked to confirm over-writing it.
778: .dc "write-files-on-make" "(variable)"
779: When set, all modified files will be written out before calling
780: make when the
781: .IQ compile-it
782: command is executed. The default is "on".
783: .dc "write-macros-to-file" "Not Bound"
784: This writes the currently defined macros to a specified file in a format
785: appropriate for reading them back in with the
786: .IQ source
787: command. The purpose of this command is to allow you to define macros
788: once and use them in other instances of JOVE.
789: .dc "write-modified-files" "C-X C-M"
790: This saves all the buffers that need saving. If you supply a numeric
791: argument it asks for each buffer whether you really want to save it.
792: .dc "write-region" "Not Bound"
793: This writes the text in the region to a specified file. If the file
794: already exists you are asked to confirm over-writing it.
795: .dc "write-word-abbrev-file" "Not Bound"
796: This writes the currently defined abbreviations to a specified file.
797: They can be read back in and automatically defined with
798: .IQ read-word-abbrev-file.
799: .dc "yank" "C-Y"
800: This undoes the last kill command. That is, it inserts the killed
801: text at point. When you do multiple kill commands in a row, they are
802: merged so that yanking them back with "C\-Y" yanks back all of them.
803: .dc "yank-pop" "ESC Y"
804: This yanks back previous killed text. \s-2JOVE\s0 has a kill ring on which
805: the last 10 kills are stored.
806: .IQ yank
807: yanks a copy of the text at the
808: front of the ring. If you want one of the last ten kills you use "ESC
809: Y" which rotates the ring so another different entry is now at the
810: front. You can use "ESC Y" only immediately following a "C-Y" or
811: another "ESC Y". If you supply a negative numeric argument the ring
812: is rotated the other way. If you use this command enough times in a
813: row you will eventually get back to where you started. Experiment
814: with this. It's extremely useful.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.