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