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