![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jove.4 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.4 CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove / doc |
1.1 root 1: .bp
2: .NH 1
3: Alphabetical List of Commands and Variables
4: .dc "prefix-1" "Escape"
5: This reads the next character and runs a command based on the character
6: typed. If you wait for more than a second or so before typing the next
7: character, the message "ESC" will be printed on the message line to
8: remind you that \s-2JOVE\s0 is waiting for another character.
9: .dc "prefix-2" "C-X"
10: This reads the next character and runs a command based on the character
11: typed. If you wait for more than a second or so before typing another
12: character, the message "C-X" will be printed on the message line to
13: remind you that \s-2JOVE\s0 is waiting for another character.
14: .dc "prefix-3" "Not Bound"
15: This reads the next character and runs a command based on the character
16: typed. If you wait for more than a second or so before typing the next
17: character, the character that invoked Prefix-3 will be printed on the
18: message line to remind you that \s-2JOVE\s0 is waiting for another one.
19: .dc "abort-char" "(variable)"
20: This variable defines \s-2JOVE'S\s0 abort characer. When the abort
21: character is typed, the current \s-2JOVE\s0 command is aborted. The
22: default value is C-G.
23: .dc "add-lisp-special" "Not Bound"
24: This command is to tell \s-2JOVE\s0 what identifiers require special
25: indentation in lisp mode. Lisp functions like defun and let are two of
26: the default functions that get treated specially. This is just a kludge
27: to define some of your own. It prompts for the function name.
28: .dc "allow-^S-and-^Q" "(variable)"
29: This variable, when set, tells \s-2JOVE\s0 that your terminal does not need
30: to use the characters C-S and C-Q for flow control, and that it is
31: okay to bind things to them. This variable should be set depending
32: upon what kind of terminal you have.
33: .dc "allow-bad-filenames" "(variable)"
34: If set, this variable permits filenames to contain "bad" characters
35: such as those from the set *&%!"`[]{}. These files are harder to deal
36: with, because the characters mean something to the shell. The default
37: value is "off".
38: .dc "ansi-codes" "Not Bound"
39: When bound to "ESC [" this makes the arrow keys, and various other keys
40: on vt100-like terminals do the right thing. For example, the up arrow
41: key will move to the previous line.
42: .dc "append-region" "Not Bound"
43: This appends the region to a specified file. If the file does not
44: already exist it is created.
45: .dc "apropos" "Not Bound"
46: This types out all the commands, variables and macros with the specific
47: keyword in their names. For each command and macro that contains the
48: string, the key sequence that can be used to execute the command or macro is
49: printed; with variables, the current value is printed. So, to find all the
50: commands that are related to windows, you type
51: .DS
52: ESC X apropos window<Return>
53: .DE
54: .dc "auto-case-abbrev" "(variable)"
55: When this variable is on (the default), word abbreviations are adjusted for
56: case automatically. For example, if "jove" were the abbreviation for
57: "jonathan's own version of emacs", then typing "jove" would give you
58: "jonathan's own version of emacs", typing "Jove" would give you "Jonathan's
59: own version of emacs", and typing "JOVE" would give you "Jonathan's Own
60: Version of Emacs". When this variable is "off", upper and lower case are
61: distinguished when looking for the abbreviation, i.e., in the example above,
62: "JOVE" and "Jove" would not be expanded unless they were defined separately.
63: .dc "auto-execute-command" "Not Bound"
64: This tells \s-2JOVE\s0 to execute a command automatically when a file whose
65: name matches a specified pattern is visited. The first argument is the
66: command you want executed and the second is a regular expression
67: pattern that specifies the files that apply. For example, if you want
68: to be in show-match-mode when you edit C source files (that is, files
69: that end with ".c" or ".h") you can type
70: .ID
71: ESC X auto-execute-command show-match-mode .*\.[ch]$
72: .DE
73: .dc "auto-execute-macro" "Not Bound"
74: This is like
75: .IQ auto-execute-command
76: except you use it to execute macros
77: automatically instead of built-in commands.
78: .dc "auto-fill-mode" "Not Bound"
79: This turns on Auto Fill mode (or off if it's currently on) in the
80: selected buffer. When \s-2JOVE\s0 is in Auto Fill mode it automatically
81: breaks lines for you when you reach the right margin so you don't have
82: to remember to hit Return. \s-2JOVE\s0 uses 78 as the right margin but you
83: can change that by setting the variable
84: .IQ right-margin
85: to another
86: value. See the
87: .IQ set
88: command to learn how to do this.
89: .dc "auto-indent-mode" "Not Bound"
90: This turns on Auto Indent mode (or off if it's currently on) in the
91: selected buffer. When \s-2JOVE\s0 is in Auto Indent mode, Return indents the
92: new line to the same position as the line you were just on. This is
93: useful for lining up C code (or any other language (but what else is
94: there besides C?)). This is out of date because of the new command
95: called
96: .IQ newline-and-indent
97: but it remains because of several
98: "requests" on the part of, uh, enthusiastic and excitable users, that
99: it be left as it is.
100: .dc "background-color" "(variable)"
101: This specifies the background color of the screen (PC version only). The
102: default value is 0, which stands for black.
103: .dc "backward-character" "C-B"
104: This moves point backward over a single character. If point is at the
105: beginning of the line it moves to the end of the previous line.
106: .dc "backward-list" "ESC C-P"
107: This moves backward over a list as opposed to an s-expression. The
108: difference between this and
109: .IQ backward-s-expression
110: is that this first searchs for a ")" and then moves to the matching "(".
111: This is useful when you're trying to find unmatched parens in a program.
112: .dc "backward-paragraph" "ESC ["
113: This moves point backward to the beginning of the current or previous
114: paragraph. Paragraphs are bounded by lines that begin with a Period or
115: Tab, or by blank lines; a change in indentation may also signal a break
116: between paragraphs, except that \s-2JOVE\s0 allows the first line of a paragraph
117: to be indented differently from the other lines.
118: .dc "backward-s-expression" "ESC C-B"
119: This moves point backward over a s-expression. It is just like
120: .IQ forward-s-expression
121: with a negative argument.
122: .dc "backward-sentence" "ESC A"
123: This moves point backward to the beginning of the current or previous
124: sentence. \s-2JOVE\s0 considers the end of a sentence to be the characters
125: ".", "!" or "?" followed by a Return or by one or more spaces.
126: .dc "backward-up-list" "ESC C-U"
127: This is similar to
128: .IQ backward-s-expression
129: except it backs up and OUT of the enclosing s-expression. In other
130: words, it moves backward to the "(" that would match a ")" if you were to
131: type it right then.
132: .dc "backward-word" "ESC B"
133: This moves point backward to the beginning of the current or previous
134: word.
135: .dc "bad-filename-extensions" "(variable)"
136: This contains a list of words separated by spaces which are to be
137: considered bad filename extensions, and so will not be counted in
138: filename completion. The default is ".o" so if you have jove.c and
139: jove.o in the same directory, the filename completion will not complain
140: of an ambiguity because it will ignore jove.o.
141: .dc "begin-kbd-macro" "C-X ("
142: This starts defining the keyboard macro by remembering all your key
143: strokes until you execute
144: .IQ end-kbd-macro,
145: by typing "C-X )". Because of a bug in \s-2JOVE\s0 you shouldn't
146: terminate the macro by typing "ESC X end-kbd-macro";
147: .IQ end-kbd-macro
148: must be bound to "C-X )" in order to make things work correctly. To
149: execute the remembered key strokes you type "C-X E" which runs the
150: .IQ execute-kbd-macro
151: command.
152: Sometimes you may want a macro to accept different input each time it runs.
153: To see how to do this, see the
154: .IQ make-macro-interactive
155: command.
156: .dc "beginning-of-file" "ESC <"
157: This moves point backward to the beginning of the buffer. This sometimes
158: prints the "Point Pushed" message. If the top of the buffer isn't on the
159: screen \s-2JOVE\s0 will set the mark so you can go back to where you were
160: if you want.
161: .dc "beginning-of-line" "C-A"
162: This moves point to the beginning of the current line.
163: .dc "beginning-of-window" "ESC ,"
164: This moves point to the beginning of the current window. The sequence
165: "ESC ," is the same as "ESC <" (beginning of file) except without the shift
166: key on the "<", and can thus can easily be remembered.
167: .dc "bind-macro-to-key" "Not Bound"
168: This is like
169: .IQ bind-to-key
170: except you use it to attach keys to named macros.
171: .dc "bind-macro-to-word-abbrev" "Not Bound"
172: This command allows you to bind a macro to a previously defined word
173: abbreviation. Whenever you type the abbreviation, it will first be expanded
174: as an abbreviation, and then the macro will be executed. Note that if the
175: macro moves around, you should set the mark first (C-@) and then exchange
176: the point and mark last (C-X C-X).
177: .dc "bind-to-key" "Not Bound"
178: This attaches a key to an internal \s-2JOVE\s0 command so that future hits on
179: that key invoke that command. For example, to make "C-W" erase the
180: previous word, you type "ESC X bind-to-key kill-previous-word C-W".
181: .dc "buffer-position" "Not Bound"
182: This displays the current file name, current line number, total number
183: of lines, percentage of the way through the file, and the position of
184: the cursor in the current line.
185: .dc "c-indentation-increment" "(variable)"
186: This variable is not currently used.
187: .dc "c-mode" "Not Bound"
188: This turns on C mode in the currently selected buffer. This is one of
189: currently four possible major modes: Fundamental, Text, C, Lisp.
190: When in C or Lisp mode, Tab, "}", and ")" behave a little differently
191: from usual: They are indented to the "right" place for C (or Lisp)
192: programs. In \s-2JOVE\s0, the "right" place is simply the way the author
193: likes it (but I've got good taste).
194: .dc "case-character-capitalize" "Not Bound"
195: This capitalizes the character after point, i.e., the character under
196: the cursor. If a negative argument is supplied that many characters
197: .IQ before
198: point are upper cased.
199: .dc "case-ignore-search" "(variable)"
200: This variable, when set, tells \s-2JOVE\s0 to treat upper and lower case as
201: the same when searching. Thus "jove" and "JOVE" would match, and
202: "JoVe" would match either. The default value of this variable is "off".
203: .dc "case-region-lower" "Not Bound"
204: This changes all the upper case letters in the region to their lower
205: case equivalent.
206: .dc "case-region-upper" "Not Bound"
207: This changes all the lower case letters in the region to their upper
208: case equivalent.
209: .dc "case-word-capitalize" "ESC C"
210: This capitalizes the current word by making the current letter upper
211: case and making the rest of the word lower case. Point is moved to
212: the end of the word. If point is not positioned on a word it is first
213: moved forward to the beginning of the next word. If a negative
214: argument is supplied that many words
215: .IQ before
216: point are capitalized.
217: This is useful for correcting the word just typed without having to
218: move point to the beginning of the word yourself.
219: .dc "case-word-lower" "ESC L"
220: This lower-cases the current word and leaves point at the end of it.
221: If point is in the middle of a word the rest of the word is
222: converted. If point is not in a word it is first moved forward to the
223: beginning of the next word. If a negative argument is supplied that
224: many words
225: .IQ before
226: point are converted to lower case. This is useful
227: for correcting the word just typed without having to move point to the
228: beginning of the word yourself.
229: .dc "case-word-upper" "ESC U"
230: This upper-cases the current word and leaves point at the end of it.
231: If point is in the middle of a word the rest of the word is
232: converted. If point is not in a word it is first moved forward to the
233: beginning of the next word. If a negative argument is supplied that
234: many words
235: .IQ before
236: point are converted to upper case. This is useful
237: for correcting the word just typed without having to move point to the
238: beginning of the word yourself.
239: .dc "cd" "Not Bound"
240: This changes the current directory.
241: .dc "character-to-octal-insert" "Not Bound"
242: This inserts a Back-slash followed by the ascii value of the next
243: character typed. For example, "C-G" inserts the string "\e007".
244: .dc "clear-and-redraw" "ESC C-L"
245: This clears the entire screen and redraws all the windows. Use this
246: when \s-2JOVE\s0 gets confused about what's on the screen, or when the screen
247: gets filled with garbage characters or output from another program.
248: .dc "comment-format" "(variable)"
249: This variable tells \s-2JOVE\s0 how to format your comments when you run the
250: command
251: .IQ fill-comment.
252: Its format is this:
253: .ID
254: <open pattern>%!<line header>%c<line trailer>%!<close pattern>
255: .DE
256: The %!, %c, and %! must appear in the format; everything else is optional.
257: A newline (represented by %n) may appear in the open or close patterns. %%
258: is the representation for %. The default comment format is for C comments.
259: See
260: .IQ fill-comment
261: for more.
262: .dc "compile-it" "C-X C-E"
263: This compiles your program by running the UNIX command "make" into a buffer,
264: and automatically parsing the error messages that are created (if any). See
265: the
266: .IQ parse-errors
267: command. To compile a C program without "make", use "C-U C-X C-E" and
268: \s-2JOVE\s0 will prompt for a command to run instead of make. (And then
269: the command you type will become the default command.) You can use this
270: to parse the output from the C compiler or the "grep" or "lint" programs.
271: See also
272: .IQ error-format-string
273: to make it possible to parse errors of a different format.
274: .dc "continue-process" "Not Bound"
275: This sends SIGCONT to the current interactive process,
276: .IQ if
277: the process
278: is currently stopped.
279: .dc "copy-region" "ESC W"
280: This takes all the text in the region and copies it onto the kill ring
281: buffer. This is just like running
282: .IQ kill-region
283: followed by the
284: .IQ yank
285: command. See the
286: .IQ kill-region
287: and
288: .IQ yank
289: commands.
290: .dc "current-error" "Not Bound"
291: This moves to the current error in the list of parsed errors. See the
292: .IQ next-error
293: and
294: .IQ previous-error
295: commands for more detailed
296: information.
297: .dc "date" "Not Bound"
298: This prints the date on the message line.
299: .dc "define-global-word-abbrev" "Not Bound"
300: This defines a global abbreviation.
301: .dc "define-macro" "Not Bound"
302: This provides a different mechanism for defining keyboard macros.
303: Instead of gathering keystrokes and storing them into the
304: "keyboard-macro" (which is how
305: .IQ start-kbd-macro
306: works),
307: .IQ define-macro
308: prompts for a macro name (terminated with Space, or Newline) and then for
309: the actual macro body. If you wish to specify control characters in the
310: macro, you may simply insert them (using the
311: .IQ quoted-insert
312: command) or by inserting the character '^' followed by the appropriate
313: letter for that character (e.g., ^A would be the two characters '^'
314: followed by 'A'). You may use Back-slash to prevent the '^' from being
315: interpreted as part of a control character when you really wish to insert
316: one (e.g., a macro body "\e^foo" would insert the string "^foo" into the
317: buffer, whereas the body "^foo" would be the same as typing ^F and then
318: inserting the string "oo"). See
319: .IQ write-macros-to-file
320: to see how to save macros.
321: .dc "define-mode-word-abbrev" "Not Bound"
322: This defines a mode-specific abbreviation.
323: .dc "delete-blank-lines" "C-X C-O"
324: This deletes all the blank lines around point. This is useful when you
325: previously opened many lines with "C-O" and now wish to delete the
326: unused ones.
327: .dc "delete-buffer" "C-X K"
328: This deletes a buffer and frees up all the memory associated with it. Be
329: careful(!) - once a buffer has been deleted it is gone forever. \s-2JOVE\s0
330: will ask you to confirm if you try to delete a buffer that needs saving.
331: This command is useful for when \s-2JOVE\s0 runs out of space to store
332: new buffers.
333: .dc "delete-current-window" "C-X D"
334: This deletes the current window and moves point into one of the
335: remaining ones. It is an error to try to delete the only remaining
336: window.
337: .dc "delete-macro" "Not Bound"
338: This deletes a macro from the list of named macros. It is an error to
339: delete the keyboard-macro. Once the macro is deleted it is gone forever.
340: If you are about to save macros to a file and decide you don't want to save
341: a particular one, delete it.
342: .dc "delete-next-character" "C-D"
343: This deletes the character that's just after point (that is, the
344: character under the cursor). If point is at the end of a line, the
345: line separator is deleted and the next line is joined with the current
346: one.
347: .dc "delete-other-windows" "C-X 1"
348: This deletes all the other windows except the current one. This can be
349: thought of as going back into One Window mode.
350: .dc "delete-previous-character" "Rubout"
351: This deletes the character that's just before point (that is, the
352: character before the cursor). If point is at the beginning of the
353: line, the line separator is deleted and that line is joined with the
354: previous one.
355: .dc "delete-white-space" "ESC \e\e"
356: This deletes all the Tabs and Spaces around point.
357: .dc "describe-bindings" "Not Bound"
358: This types out a list containing each bound key and the command that gets
359: invoked every time that key is typed. To make a wall chart of \s-2JOVE\s0
360: commands, set
361: .IQ send-typeout-to-buffer
362: to "on" and \s-2JOVE\s0 will
363: store the key bindings in a buffer which you can save to a file and then
364: print.
365: .dc "describe-command" "Not Bound"
366: This prints some info on a specified command.
367: .dc "describe-key" "Not Bound"
368: This waits for you to type a key and then tells the name of the
369: command that gets invoked every time that key is hit. Once you have
370: the name of the command you can use the
371: .IQ describe-command
372: command
373: to find out exactly what it does.
374: .dc "describe-variable" "Not Bound"
375: This prints some info on a specified variable.
376: .dc "digit" "ESC [0-9]"
377: This reads a numeric argument. When you type "ESC" followed by a
378: number, "digit" keeps reading numbers until you type some other
379: command. Then that command is executes with the numeric argument you
380: specified.
381: .dc "digit-1" "Not Bound"
382: This pretends you typed "ESC 1". This is useful for terminals that
383: have keypads that send special sequences for numbers typed on the
384: keypad as opposed to numbers typed from the keyboard. This can save
385: having type "ESC" when you want to specify an argument.
386: .dc "digit-2" "Not Bound"
387: This pretends you typed "ESC 2". This is useful for terminals that
388: have keypads that send special sequences for numbers typed on the
389: keypad as opposed to numbers typed from the keyboard. This can save
390: having type "ESC" when you want to specify an argument.
391: .dc "digit-3" "Not Bound"
392: This pretends you typed "ESC 3". This is useful for terminals that
393: have keypads that send special sequences for numbers typed on the
394: keypad as opposed to numbers typed from the keyboard. This can save
395: having type "ESC" when you want to specify an argument.
396: .dc "digit-4" "Not Bound"
397: This pretends you typed "ESC 4". This is useful for terminals that
398: have keypads that send special sequences for numbers typed on the
399: keypad as opposed to numbers typed from the keyboard. This can save
400: having type "ESC" when you want to specify an argument.
401: .dc "digit-5" "Not Bound"
402: This pretends you typed "ESC 5". This is useful for terminals that
403: have keypads that send special sequences for numbers typed on the
404: keypad as opposed to numbers typed from the keyboard. This can save
405: having type "ESC" when you want to specify an argument.
406: .dc "digit-6" "Not Bound"
407: This pretends you typed "ESC 6". This is useful for terminals that
408: have keypads that send special sequences for numbers typed on the
409: keypad as opposed to numbers typed from the keyboard. This can save
410: having type "ESC" when you want to specify an argument.
411: .dc "digit-7" "Not Bound"
412: This pretends you typed "ESC 7". This is useful for terminals that
413: have keypads that send special sequences for numbers typed on the
414: keypad as opposed to numbers typed from the keyboard. This can save
415: having type "ESC" when you want to specify an argument.
416: .dc "digit-8" "Not Bound"
417: This pretends you typed "ESC 8". This is useful for terminals that
418: have keypads that send special sequences for numbers typed on the
419: keypad as opposed to numbers typed from the keyboard. This can save
420: having type "ESC" when you want to specify an argument.
421: .dc "digit-9" "Not Bound"
422: This pretends you typed "ESC 9". This is useful for terminals that
423: have keypads that send special sequences for numbers typed on the
424: keypad as opposed to numbers typed from the keyboard. This can save
425: having type "ESC" when you want to specify an argument.
426: .dc "digit-0" "Not Bound"
427: This pretends you typed "ESC 0". This is useful for terminals that
428: have keypads that send special sequences for numbers typed on the
429: keypad as opposed to numbers typed from the keyboard. This can save
430: having type "ESC" when you want to specify an argument.
431: .dc "dirs" "Not Bound"
432: This prints out the directory stack. See the "cd", "pushd", "popd"
433: commands for more info.
434: .dc "disable-biff" "(variable)"
435: When this is set, \s-2JOVE\s0 disables biff when you're editing and enables it
436: again when you get out of \s-2JOVE\s0, or when you pause to the parent shell
437: or push to a new shell. (This means arrival of new mail will not be
438: immediately apparent but will not cause indiscriminate writing on the
439: display). The default is "off".
440: .dc "display-bad-filenames" "(variable)"
441: This variable affects only filename completion, in particular, what
442: happens when "?" is typed while prompting for a file. When this variable
443: is ON, any files that end with one of the extensions defined by the
444: variable
445: .IQ bad-filename-extensions
446: will be displayed with an "!" in front of their names. When
447: .IQ display-bad-filenames
448: is OFF the files will not be displayed at all. The default value is on.
449: .dc "down-list" "ESC C-D"
450: This is the opposite of
451: .IQ backward-up-list.
452: It's not clear to me that this command serves any useful purpose in
453: life. Try it out, and let me know what you think.
454: .dc "dstop-process" "Not Bound"
455: Send the "dsusp" character to the current process. This is the
456: character that suspends a process on the next read from the
457: terminal. Most people have it set to C-Y. This only works if
458: you have the interactive process feature, and if you are in a
459: buffer bound to a process.
460: .dc "edit-word-abbrevs" "Not Bound"
461: This creates a buffer with a list of each abbreviation and the phrase
462: it expands into, and enters a recursive edit to let you change the
463: abbreviations or add some more. The format of this list is
464: "abbreviation:phrase" so if you add some more you should follow that
465: format. It's probably simplest just to copy some already existing
466: abbreviations and edit them. When you are done you type "C-X C-C" to
467: exit the recursive edit.
468: .dc "end-kbd-macro" "C-X )"
469: This stops the definition of the keyboard macro. Because of a bug in
470: \s-2JOVE\s0, this must be bound to "C-X )", or some key sequence which is
471: one or two characters long. Anything else will not work properly.
472: .dc "end-of-file" "ESC >"
473: This moves point forward to the end of the buffer. This sometimes
474: prints the "Point Pushed" message. If the end of the buffer isn't on
475: the screen \s-2JOVE\s0 will set the mark so you can go back to where you were
476: if you want.
477: .dc "end-of-line" "C-E"
478: This moves point to the end of the current line. If the line is too
479: long to fit on the screen \s-2JOVE\s0 will scroll the line to the left to
480: make the end of the line visible. The line will slide back to its
481: normal position when you move backward past the leftmost visible character
482: or when you move off the line altogether.
483: .dc "end-of-window" "ESC ."
484: This moves point to the last character in the window.
485: .dc "eof-process" "Not Bound"
486: Sends EOF to the current interactive process. This only works on
487: versions of \s-2JOVE\s0 running under versions of UNIX with pty's.
488: .dc "erase-buffer" "Not Bound"
489: This erases the contents of the specified buffer. This is like
490: .IQ delete-buffer
491: except it only erases the contents of the buffer, not
492: the buffer itself. If you try to erase a buffer that needs saving you
493: will be asked to confirm it.
494: .dc "error-format-string" "(variable)"
495: This is the error format string that is used by
496: .IQ parse-errors
497: to find the error messages in a buffer. The way it works is by using
498: this string as a \s-2JOVE\s0 regular expression search string, where the
499: \e('s and \e)'s regular expression operators are used to pick out the
500: file name and line number from the line containing an error message. For
501: instance, a typical error message might look like this:
502: .sp 1
503: "file.c", line 540: missing semi-colon
504: .sp 1
505: For strings of this format, an appropriate value for
506: .IQ error-format-string
507: would be something like this:
508: .sp 1
509: ^"\e([^"]*\e)", line \e([0-9]*\e):
510: .sp 1
511: What this means is, to find an error message, search for a line beginning
512: with a double-quote. Then it says that all the following characters up
513: to another double-quote should be remembered as one unit, namely the
514: filename that the error is in (that's why the first set of parens are
515: surrounding it). Then it says that after the filename there will be the
516: string ", line " followed by a line number, which should be remembered as
517: a single unit (which is why the second set of parens is around that).
518: The only constraints on the error messages is that the file name and line
519: number appear on the same line, and that the file name appears before the
520: line number. Most compilers seem to do this anyway, so this is not an
521: unreasonable restriction.
522: .sp 1
523: If you do not know how to use regular expressions then this variable will
524: be hard for you to use. Also note that you can look at the default
525: value of this variable by printing it out, but it is a really complicated
526: string because it is trying to accommodate the outputs of more than one
527: compiler at a time.
528: .dc "error-window-size" "(variable)"
529: This is the percentage of the screen to use for the error-window on the
530: screen. When you execute
531: .IQ compile-it,
532: .IQ error-window-size
533: percent of the screen will go to the error window. If the window already
534: exists and is a different size, it is made to be this size. The default
535: value is 20%.
536: .dc "exchange-point-and-mark" "C-X C-X"
537: This moves point to mark and makes mark the old point. This is for
538: quickly moving from one end of the region to another.
539: .dc "execute-kbd-macro" "C-X E"
540: This executes the keyboard macro. If you supply a numeric argument the
541: macro is executed that many times.
542: .dc "execute-macro" "Not Bound"
543: This executes a specified macro. If you supply a numeric argument the
544: macro is executed that many times.
545: .dc "execute-named-command" "ESC X"
546: This is the way to execute a command that isn't bound to any key. When
547: you are prompted with ": " you can type the name of the command. You
548: don't have to type the entire name. Once the command is unambiguous you
549: can type Space and \s-2JOVE\s0 will fill in the rest for you. If you are
550: not sure of the name of the command, type "?" and \s-2JOVE\s0 will print
551: a list of all the commands that you could possibly match given what
552: you've already typed. If you don't have any idea what the command's name
553: is but you know it has something to do with windows (for example), you
554: can do "ESC X apropos window" and \s-2JOVE\s0 will print a list of all
555: the commands that are related to windows. If you find yourself
556: constantly executing the same commands this way you probably want to bind
557: them to keys so that you can execute them more quickly. See the
558: .IQ bind-to-key
559: command.
560: .dc "exit-jove" "C-X C-C"
561: This exits \s-2JOVE\s0. If any buffers need saving \s-2JOVE\s0 will print a warning
562: message and ask for confirmation. If you leave without saving your
563: buffers all your work will be lost. If you made a mistake and really
564: do want to exit then you can. If you are in a recursive editing level
565: .IQ exit-jove
566: will return you from that.
567: .dc "expand-environment-variables" "Variable"
568: When this variable is on JOVE will try to expand any strings of the form
569: "$var" into the value of the environment variable "var" when in the
570: minibuffer. For example, if you type $HOME/.joverc, "$HOME" will be
571: replaced with you home directory. The default value is off.
572: .dc "file-creation-mode" "(variable)"
573: This variable has an octal value. It contains the mode (see
574: .IQ chmod(1)
575: ) with which files should be created. This mode gets modified by your
576: current umask setting (see
577: .IQ umask(1)
578: ). The default value is usually
579: .IQ 0666
580: or
581: .IQ 0644.
582: .dc "files-should-end-with-newline" "(variable)"
583: This variable indicates that all files should always have a newline
584: at the end. This is often necessary for line printers and the like.
585: When set, if \s-2JOVE\s0 is writing a file whose last character is not a
586: newline, it will add one automatically.
587: .dc "fill-comment" "Not Bound"
588: This command fills in your C comments to make them pretty and readable.
589: This filling is done according the variable
590: .IQ comment-format.
591: .DS L
592: /*
593: * the default format makes comments like this.
594: */
595: .DE
596: This can be changed by changing the format variable. Other languages
597: may be supported by changing the format variable appropriately. The
598: formatter looks backwards from dot for an open comment symbol. If
599: found, all indentation is done relative the position of the first character
600: of the open symbol. If there is a matching close symbol, the entire
601: comment is formatted. If not, the region between dot and the open symbol
602: is reformatted.
603: .dc "fill-paragraph" "ESC J"
604: This rearranges words between lines so that all the lines in the current
605: paragraph extend as close to the right margin as possible, ensuring that
606: none of the lines will be greater than the right margin. The default value
607: for
608: .IQ right-margin
609: is 78, but can be changed with the
610: .IQ set
611: and
612: .IQ right-margin-here
613: commands. \s-2JOVE\s0 has a complicated algorithm
614: for determining the beginning and end of the paragraph. In the normal case
615: \s-2JOVE\s0 will give all the lines the same indent as they currently have,
616: but if you wish to force a new indent you can supply a numeric argument to
617: .IQ fill-paragraph
618: (e.g., by typing C-U ESC J)
619: and \s-2JOVE\s0 will indent each line to the column
620: specified by the
621: .IQ left-margin
622: variable. See also the
623: .IQ left-margin
624: variable and
625: .IQ left-margin-here
626: command.
627: .dc "fill-region" "Not Bound"
628: This is like
629: .IQ fill-paragraph,
630: except it operates on a region instead of
631: just a paragraph.
632: .dc "filter-region" "Not Bound"
633: This sends the text in the region to a UNIX command, and replaces the
634: region with the output from that command. For example, if you are
635: lazy and don't like to take the time to write properly indented C
636: code, you can put the region around your C file and
637: .IQ filter-region
638: it
639: through
640: .IQ cb,
641: the UNIX C beautifier. If you have a file that contains
642: a bunch of lines that need to be sorted you can do that from inside
643: \s-2JOVE\s0 too, by filtering the region through the
644: .IQ sort
645: UNIX command.
646: Before output from the command replaces the region \s-2JOVE\s0 stores the old
647: text in the kill ring, so if you are unhappy with the results you can
648: easily get back the old text with "C-Y".
649: .dc "find-file" "C-X C-F"
650: This visits a file into its own buffer and then selects that buffer.
651: If you've already visited this file in another buffer, that buffer is
652: selected. If the file doesn't yet exist, \s-2JOVE\s0 will print "(New file)"
653: so that you know.
654: .dc "find-tag" "C-X T"
655: This finds the file that contains the specified tag. \s-2JOVE\s0 looks up
656: tags by default in the "tags" file in the current directory. You can change
657: the default tag name by setting the
658: .IQ tag-file
659: variable to another
660: name. If you specify a numeric argument to this command, you will be
661: prompted for a tag file. This is a good way to specify another tag file
662: without changing the default. If the tag cannot be found the error is
663: reported and point stays where it is.
664: .dc "find-tag-at-point" "Not Bound"
665: This finds the file that contains the tag that point is currently on.
666: See
667: .IQ find-tag.
668: .dc "first-non-blank" "ESC M"
669: This moves point back to the indent of the current line.
670: .dc "foreground-color" "(variable)"
671: This specifies the foreground color of the screen (PC version only). The
672: default is 1, which stands for white. The attribute used for writing to
673: the screen is formed by (bg&7)<<4 & (fg&7).
674: .dc "forward-character" "C-F"
675: This moves forward over a single character. If point is at the end of
676: the line it moves to the beginning of the next one.
677: .dc "forward-list" "ESC C-N"
678: This is like
679: .IQ forward-s-expression
680: except it moves over lists ONLY. What this does is search for the next
681: "(" and then move to the matching ")". This is useful for when you are
682: trying to find mismatched parentheses in a program.
683: .dc "forward-paragraph" "ESC ]"
684: This moves point forward to the end of the current or next paragraph.
685: Paragraphs are bounded by lines that begin with a Period or Tab, or by blank
686: lines; a change in indentation may also signal a break between paragraphs,
687: except that \s-2JOVE\s0 allows the first line of a paragraph to be indented
688: differently from the other lines.
689: .dc "forward-s-expression" "ESC C-F"
690: This moves point forward over a s-expression. If the first significant
691: character after point is "(", this moves past the matching ")". If the
692: character begins an identifier, this moves just past it. This is mode
693: dependent, so this will move over atoms in LISP mode and C identifiers in C
694: mode. \s-2JOVE\s0 also matches "{".
695: .dc "forward-sentence" "ESC E"
696: This moves point forward to the end of the current or next sentence.
697: \s-2JOVE\s0 considers the end of a sentence to be the characters ".", "!" or
698: "?" followed by a Return, or one or more spaces.
699: .dc "forward-word" "ESC F"
700: This moves point forward to the end of the current or next word.
701: .dc "fundamental-mode" "Not Bound"
702: This sets the major mode to Fundamental. This affects what \s-2JOVE\s0
703: considers as characters that make up words. For instance,
704: Single-quote is not part of a word in Fundamental mode, but is in Text
705: mode.
706: .dc "gather-numeric-argument" "C-U"
707: This command is one of two ways to specify a numeric argument to a
708: command. It's usually bound to C-U. Typing C-U once means, Do the next
709: command 4 times. Typing C-U twice will do the next command 16 times, and
710: so on. If at any point you type a number, then that number will be used
711: instead of 4. For instance, C-U 3 5 means do the next command 35 times.
712: .dc "goto-line" "ESC G"
713: If a numeric argument is supplied point moves to the beginning of that
714: line. If no argument is supplied one is prompted for.
715: .dc "goto-window-with-buffer" "Not Bound"
716: This command prompts for a buffer name and then selects that buffer. If
717: the buffer is currently being displayed in one of the windows, that
718: window is selected instead.
719: .dc "grind-s-expr" "Not Bound"
720: When point is positioned on a "(", this re-indents that LISP expression.
721: .dc "grow-window" "C-X ^"
722: This makes the current window one line bigger. This only works when
723: there is more than one window and provided there is room to change the
724: size.
725: .dc "handle-tab" "Tab"
726: This handles indenting to the "right" place in C and Lisp mode, and
727: just inserts itself in Text mode.
728: .dc "i-search-forward" "Not Bound"
729: Incremental search. Like search-forward except that instead of prompting
730: for a string and searching for that string all at once, it accepts the string
731: one character at a time. After each character you type as part of the search
732: string, it searches for the entire string so far. When you like what it
733: found, type the Return key to finish the search. You can take back a
734: character with Rubout and the search will back up to the position before
735: that character was typed. C-G aborts the search.
736: .dc "i-search-reverse" "Not Bound"
737: Incremental search. Like search-reverse except that instead of prompting
738: for a string and searching for that string all at once, it accepts the string
739: one character at a time. After each character you type as part of the search
740: string, it searches for the entire string so far. When you like what it
741: found, type the Return key to finish the search. You can take back a
742: character with Rubout and the search will back up to the position before
743: that character was typed. C-G aborts the search.
744: .dc "i-shell-command" "Not Bound"
745: This is like
746: .IQ shell-command
747: except it lets you continue with your
748: editing while the command is running. This is really useful for long
749: running commands with sporadic output. See the manual for information
750: on how to use interactive processes.
751: .dc "insert-file" "C-X C-I"
752: This inserts a specified file into the current buffer at point. Point
753: is positioned at the beginning of the inserted file.
754: .dc "internal-tabstop" "(variable)"
755: The number of spaces \s-2JOVE\s0 should print when it displays a tab character.
756: The default value is 8.
757: .dc "interrupt-character" "(variable)"
758: This is set to the character that interrupts JOVE (with a signal) no matter
759: what JOVE is doing. It's main use is for interrupting non-interactive
760: processes, but it also has uses for debugging. Unfortunately there is no
761: way to turn off the interrupt character.
762: .dc "interrupt-process" "Not Bound"
763: This sends the interrupt character (usually C-C) to the interactive process
764: in the current buffer. This is only for versions of \s-2JOVE\s0 that have the
765: interactive processes feature. This only works when you are inside a buffer
766: that's attached to a process.
767: .dc "kill-next-word" "ESC D"
768: This kills the text from point to the end of the current or next word.
769: .dc "kill-previous-word" "ESC Rubout"
770: This kills the text from point to the beginning of the current or
771: previous word.
772: .dc "kill-process" "Not Bound"
773: This command prompts for a buffer name or buffer number (just as
774: select-buffer does) and then sends the process in that buffer a
775: kill signal (9).
776: .dc "kill-region" "C-W"
777: This deletes the text in the region and saves it on the kill ring.
778: Commands that delete text but save it on the kill ring all have the
779: word "kill" in their names. Type "C-Y" to yank back the most recent
780: kill.
781: .dc "kill-s-expression" "ESC C-K"
782: This kills the text from point to the end of the current or next
783: s-expression.
784: .dc "kill-some-buffers" "Not Bound"
785: This goes through all the existing buffers and asks whether or not to kill
786: them. If you decide to kill a buffer, and it turns out that the buffer is
787: modified, \s-2JOVE\s0 will offer to save it first. This is useful for when \s-2JOVE\s0
788: runs out of memory to store lines (this only happens on PDP-11's) and you
789: have lots of buffers that you are no longer using.
790: .dc "kill-to-beginning-of-sentence" "C-X Rubout"
791: This kills from point to the beginning of the current or previous
792: sentence.
793: .dc "kill-to-end-of-line" "C-K"
794: This kills from point to the end of the current line. When point is
795: at the end of the line the line separator is deleted and the next line
796: is joined with current one. If a numeric argument is supplied that
797: many lines are killed; if the argument is negative that many lines
798: .IQ before
799: point are killed; if the argument is zero the text from point
800: to the beginning of the line is killed.
801: .dc "kill-to-end-of-sentence" "ESC K"
802: This kills from point to the end of the current or next sentence. If a
803: negative numeric argument is supplied it kills from point to the
804: beginning of the current or previous sentence.
805: .dc "left-margin" "(variable)"
806: This is how far lines should be indented when auto-indent mode is on,
807: or when the
808: .IQ newline-and-indent
809: command is run (usually by typing
810: LineFeed). It is also used by fill-paragraph and auto-fill mode.
811: If the value is zero (the default) then the left margin is determined
812: from the surrounding lines.
813: .dc "left-margin-here" "Not Bound"
814: This sets the
815: .IQ left-margin
816: variable to the current position of
817: point. This is an easy way to say, "Make the left margin begin here,"
818: without having to count the number of spaces over it actually is.
819: .dc "lisp-mode" "Not Bound"
820: This turns on Lisp mode. Lisp mode is one of four mutually exclusive major
821: modes: Fundamental, Text, C, and Lisp. In Lisp mode, the characters Tab
822: and ) are treated specially, similar to the way they are treated in C mode.
823: Also, Auto Indent mode is affected, and handled specially.
824: .dc "list-buffers" "C-X C-B"
825: This types out a list containing various information about each buffer.
826: Right now that list looks like this:
827: .DS
828: .ta \w'NO111'u +\w'Lines1'u +\w'Scratch111'u +\w'*1'u +\w'commands.doc111'u
829: \ (* means the buffer needs saving)
830: \ NO Lines Type Name File
831: \ -- ----- ---- ---- ----
832: \ 1 1 File Main [No file]
833: \ 2 1 Scratch * Minibuf [No file]
834: \ 3 519 File * commands.doc commands.doc
835: .DE
836: The first column lists the buffer's number. When \s-2JOVE\s0 prompts for a
837: buffer name you can either type in the full name, or you can simply
838: type the buffer's number. The second column is the number of lines in
839: the buffer. The third says what type of buffer. There are four
840: types: "File", "Scratch", "Process", "I-Process". "File" is simply a
841: buffer that holds a file; "Scratch" is for buffers that \s-2JOVE\s0 uses
842: internally; "Process" is one that holds the output from a UNIX
843: command; "I-Process" is one that has an interactive process attached to
844: it. The next column contains the name of the buffer. And the last
845: column is the name of the file that's attached to the buffer. In this
846: case, both Minibuf and commands.doc have been changed but not yet
847: saved. In fact Minibuf won't be saved since it's an internal \s-2JOVE\s0
848: buffer that I don't even care about.
849: .dc "list-processes" "Not Bound"
850: This makes a list somewhat like "list-buffers" does, except its
851: list consists of the current interactive processes. Right now the list
852: looks like this:
853: .DS
854: .ta \w'shell-111111111111'u +\w'Running1111111111'u
855: \ Buffer Status Pid Command
856: \ ------ ------ --- -------
857: \ *shell* Running 18415 shell
858: \ fgrep Done 18512 fgrep -n Buffer *.c
859: .DE
860: The first column has the name of the buffer to which the process is
861: attached. The second has the status of the process; if a process has
862: exited normally the status is "Done" as in fgrep; if the process
863: exited with an error the status is "Exit N" where N is the value of
864: the exit code; if the process was killed by some signal the status is
865: the name of the signal that was used; otherwise the process is
866: running. The last column is the name of the command that is being run.
867: .dc "mail-check-frequency" "(variable)"
868: This is how often (in seconds) \s-2JOVE\s0 should check your mailbox for
869: incoming mail. See also the
870: .IQ mailbox
871: and
872: .IQ disable-biff
873: variables.
874: .dc "mailbox" "(variable)"
875: Set this to the full pathname of your mailbox. \s-2JOVE\s0 will look here to
876: decide whether or not you have any unread mail. This defaults to
877: /usr/spool/mail/$USER, where $USER is set to your login name.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.