![[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 / share / doc / usd / 17.jove|
Return to jove.4 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 17.jove |
1.1 root 1: .\" @(#)jove.4 6.1 (Berkeley) 5/30/86
2: .\"
3: .bp
4: .NH 1
5: Alphabetical List of Commands and Variables
6: .dc "Prefix-1" "Escape"
7: This reads the next character and runs a command based on the character
8: typed. If you wait for more than a second or so before typing the next
9: character, the message "ESC" will be printed on the message line to
10: remind you that \s-2JOVE\s0 is waiting for another character.
11: .dc "Prefix-2" "C-X"
12: This reads the next character and runs a command based on the character
13: typed. If you wait for more than a second or so before typing another
14: character, the message "C-X" will be printed on the message line to
15: remind you that \s-2JOVE\s0 is waiting for another character.
16: .dc "Prefix-3" "Not Bound"
17: This reads the next character and runs a command based on the character
18: typed. If you wait for more than a second or so before typing the next
19: character, the character that invoked Prefix-3 will be printed on the
20: message line to remind you that \s-2JOVE\s0 is waiting for another one.
21: .dc "allow-^S-and-^Q" "(variable)"
22: This variable, when set, tells \s-2JOVE\s0 that your terminal does not need
23: to use the characters C-S and C-Q for flow control, and that it is
24: okay to bind things to them. This variable should be set depending
25: upon what kind of terminal you have.
26: .dc "allow-bad-filenames" "(variable)"
27: If set, this variable permits filenames to contain "bad" characters
28: such as those from the set *&%!"`[]{}. These files are harder to deal
29: with, because the characters mean something to the shell. The default
30: value is "off".
31: .dc "append-region" "Not Bound"
32: This appends the region to a specified file. If the file does not
33: already exist it is created.
34: .dc "apropos" "Not Bound"
35: This types out all the commands, variables and macros with the specific
36: keyword in their names. For each command and macro that contains the
37: string, the key sequence that can be used to execute the command or macro is
38: printed; with variables, the current value is printed. So, to find all the
39: commands that are related to windows, you type
40: .DS
41: ESC X apropos window<Return>
42: .DE
43: .dc "auto-case-abbrev" "(variable)"
44: When this variable is on (the default), word abbreviations are adjusted for
45: case automatically. For example, if "jove" were the abbreviation for
46: "jonathan's own version of emacs", then typing "jove" would give you
47: "jonathan's own version of emacs", typing "Jove" would give you "Jonathan's
48: own version of emacs", and typing "JOVE" would give you "Jonathan's Own
49: Version of Emacs". When this variable is "off", upper and lower case are
50: distinguished when looking for the abbreviation, i.e., in the example above,
51: "JOVE" and "Jove" would not be expanded unless they were defined separately.
52: .dc "auto-execute-command" "Not Bound"
53: This tells \s-2JOVE\s0 to execute a command automatically when a file whose
54: name matches a specified pattern is visited. The first argument is the
55: command you want executed and the second is a regular expression
56: pattern that specifies the files that apply. For example, if you want
57: to be in show-match-mode when you edit C source files (that is, files
58: that end with ".c" or ".h") you can type
59: .ID
60: ESC X auto-execute-command show-match-mode .*\.[ch]$
61: .DE
62: .dc "auto-execute-macro" "Not Bound"
63: This is like
64: .IQ auto-execute-command
65: except you use it to execute macros
66: automatically instead of built-in commands.
67: .dc "auto-fill-mode" "Not Bound"
68: This turns on Auto Fill mode (or off if it's currently on) in the
69: selected buffer. When \s-2JOVE\s0 is in Auto Fill mode it automatically
70: breaks lines for you when you reach the right margin so you don't have
71: to remember to hit Return. \s-2JOVE\s0 uses 78 as the right margin but you
72: can change that by setting the variable
73: .IQ right-margin
74: to another
75: value. See the
76: .IQ set
77: command to learn how to do this.
78: .dc "auto-indent-mode" "Not Bound"
79: This turns on Auto Indent mode (or off if it's currently on) in the
80: selected buffer. When \s-2JOVE\s0 is in Auto Indent mode, Return indents the
81: new line to the same position as the line you were just on. This is
82: useful for lining up C code (or any other language (but what else is
83: there besides C?)). This is out of date because of the new command
84: called
85: .IQ newline-and-indent
86: but it remains because of several
87: "requests" on the part of, uh, enthusiastic and excitable users, that
88: it be left as it is.
89: .dc "backward-character" "C-B"
90: This moves point backward over a single character. If point is at the
91: beginning of the line it moves to the end of the previous line.
92: .dc "backward-paragraph" "ESC ["
93: This moves point backward to the beginning of the current or previous
94: paragraph. Paragraphs are bounded by lines that begin with a Period or
95: Tab, or by blank lines; a change in indentation may also signal a break
96: between paragraphs, except that \s-2JOVE\s0 allows the first line of a paragraph
97: to be indented differently from the other lines.
98: .dc "backward-s-expression" "ESC C-B"
99: This moves point backward over a s-expression. It is just like
100: .IQ forward-s-expression
101: with a negative argument.
102: .dc "backward-sentence" "ESC A"
103: This moves point backward to the beginning of the current or previous
104: sentence. \s-2JOVE\s0 considers the end of a sentence to be the characters
105: ".", "!" or "?" followed by a Return or by one or more spaces.
106: .dc "backward-word" "ESC B"
107: This moves point backward to the beginning of the current or previous
108: word.
109: .dc "bad-filename-extensions" "(variable)"
110: This contains a list of words separated by spaces which are to be
111: considered bad filename extensions, and so will not be counted in
112: filename completion. The default is ".o" so if you have jove.c and
113: jove.o in the same directory, the filename completion will
114: .IQ not
115: complain
116: of an ambiguity because it will ignore jove.o.
117: .dc "beginning-of-file" "ESC <"
118: This moves point backward to the beginning of the buffer. This
119: sometimes prints the "Point Pushed" message. If the top of the buffer
120: isn't on the screen \s-2JOVE\s0 will set the mark so you can go back to where
121: you were if you want.
122: .dc "beginning-of-line" "C-A"
123: This moves point to the beginning of the current line.
124: .dc "beginning-of-window" "ESC ,"
125: This moves point to the beginning of the current window. The sequence
126: "ESC ," is the same as "ESC <" (beginning of file) except without the shift
127: key on the "<", and can thus can easily be remembered.
128: .dc "bind-to-key" "Not Bound"
129: This attaches a key to an internal \s-2JOVE\s0 command so that future hits on
130: that key invoke that command. For example, to make "C-W" erase the
131: previous word, you type "ESC X bind-to-key kill-previous-word C-W".
132: .dc "bind-macro-to-key" "Not Bound"
133: This is like
134: .IQ bind-to-key
135: except you use it to attach keys to
136: named macros.
137: .dc "bind-macro-to-word-abbrev" "Not Bound"
138: This command allows you to bind a macro to a previously defined word
139: abbreviation. Whenever you type the abbreviation, it will first be expanded
140: as an abbreviation, and then the macro will be executed. Note that if the
141: macro moves around, you should set the mark first (C-@) and then exchange
142: the point and mark last (C-X C-X).
143: .dc "buffer-position" "Not Bound"
144: This displays the current file name, current line number, total number
145: of lines, percentage of the way through the file, and the position of
146: the cursor in the current line.
147: .dc "c-mode" "Not Bound"
148: This turns on C mode in the currently selected buffer. This is one of
149: currently four possible major modes: Fundamental, Text, C, Lisp.
150: When in C or Lisp mode, Tab, "}", and ")" behave a little differently
151: from usual: They are indented to the "right" place for C (or Lisp)
152: programs. In \s-2JOVE\s0, the "right" place is simply the way the author
153: likes it (but I've got good taste).
154: .dc "case-character-capitalize" "Not Bound"
155: This capitalizes the character after point, i.e., the character undo
156: the cursor. If a negative argument is supplied that many characters
157: .IQ before
158: point are upper cased.
159: .dc "case-ignore-search" "(variable)"
160: This variable, when set, tells \s-2JOVE\s0 to treat upper and lower case as
161: the same when searching. Thus "jove" and "JOVE" would match, and
162: "JoVe" would match either. The default value of this variable is "off".
163: .dc "case-region-lower" "Not Bound"
164: This changes all the upper case letters in the region to their lower
165: case equivalent.
166: .dc "case-region-upper" "Not Bound"
167: This changes all the lower case letters in the region to their upper
168: case equivalent.
169: .dc "case-word-capitalize" "ESC C"
170: This capitalizes the current word by making the current letter upper
171: case and making the rest of the word lower case. Point is moved to
172: the end of the word. If point is not positioned on a word it is first
173: moved forward to the beginning of the next word. If a negative
174: argument is supplied that many words
175: .IQ before
176: point are capitalized.
177: This is useful for correcting the word just typed without having to
178: move point to the beginning of the word yourself.
179: .dc "case-word-lower" "ESC L"
180: This lower-cases the current word and leaves point at the end of it.
181: If point is in the middle of a word the rest of the word is
182: converted. If point is not in a word it is first moved forward to the
183: beginning of the next word. If a negative argument is supplied that
184: many words
185: .IQ before
186: point are converted to lower case. This is useful
187: for correcting the word just typed without having to move point to the
188: beginning of the word yourself.
189: .dc "case-word-upper" "ESC U"
190: This upper-cases the current word and leaves point at the end of it.
191: If point is in the middle of a word the rest of the word is
192: converted. If point is not in a word it is first moved forward to the
193: beginning of the next word. If a negative argument is supplied that
194: many words
195: .IQ before
196: point are converted to upper case. This is useful
197: for correcting the word just typed without having to move point to the
198: beginning of the word yourself.
199: .dc "character-to-octal-insert" "Not Bound"
200: This inserts a Back-slash followed by the ascii value of the next
201: character typed. For example, "C-G" inserts the string "\\007".
202: .dc "cd" "Not Bound"
203: This changes the current directory.
204: .dc "clear-and-redraw" "ESC C-L"
205: This clears the entire screen and redraws all the windows. Use this
206: when \s-2JOVE\s0 gets confused about what's on the screen, or when the screen
207: gets filled with garbage characters or output from another program.
208: .dc "comment-format" "(variable)"
209: This variable tells \s-2JOVE\s0 how to format your comments when you run the
210: command
211: .IQ fill-comment.
212: Its format is this:
213: .ID
214: <open pattern>%!<line header>%c<line trailer>%!<close pattern>
215: .DE
216: The %!, %c, and %! must appear in the format; everything else is optional.
217: A newline (represented by %n) may appear in the open or close patterns. %%
218: is the representation for %. The default comment format is for C comments.
219: See
220: .IQ fill-comment
221: for more.
222: .dc "compile-it" "C-X C-E"
223: This compiles your program by running the UNIX command "make" into a buffer,
224: and automatically parsing the error messages that are created (if any). See
225: the
226: .IQ parse-errors
227: and
228: .IQ parse-special-errors
229: commands. To compile
230: a C program without "make", use "C-U C-X C-E" and \s-2JOVE\s0 will prompt
231: for a command to run instead of make. (And then the command you type will
232: become the default command.) You can use this to parse the output from the
233: C compiler or the "grep" or "lint" programs.
234: .dc "continue-process" "Not Bound"
235: This sends SIGCONT to the current interactive process,
236: .IQ if
237: the process
238: is currently stopped.
239: .dc "copy-region" "ESC W"
240: This takes all the text in the region and copies it onto the kill ring
241: buffer. This is just like running
242: .IQ kill-region
243: followed by the
244: .IQ yank
245: command. See the
246: .IQ kill-region
247: and
248: .IQ yank
249: commands.
250: .dc "current-error" "Not Bound"
251: This moves to the current error in the list of parsed errors. See the
252: .IQ next-error
253: and
254: .IQ previous-error
255: commands for more detailed
256: information.
257: .dc "date" "Not Bound"
258: This prints the date on the message line.
259: .dc "define-mode-word-abbrev" "Not Bound"
260: This defines a mode-specific abbreviation.
261: .dc "define-global-word-abbrev" "Not Bound"
262: This defines a global abbreviation.
263: .dc "delete-blank-lines" "C-X C-O"
264: This deletes all the blank lines around point. This is useful when you
265: previously opened many lines with "C-O" and now wish to delete the
266: unused ones.
267: .dc "delete-buffer" "C-X K"
268: This deletes a buffer and frees up all the memory associated with it.
269: Be careful! Once a buffer has been deleted it is gone forever. \s-2JOVE\s0
270: will ask you to confirm if you try to delete a buffer that needs
271: saving. This command is useful for when \s-2JOVE\s0 runs out of space to
272: store new buffers.
273: .dc "delete-macro" "Not Bound"
274: This deletes a macro from the list of named macros. It is an error to
275: delete the keyboard-macro. Once the macro is deleted it is gone forever.
276: If you are about to save macros to a file and decide you don't want to save
277: a particular one, delete it.
278: .dc "delete-next-character" "C-D"
279: This deletes the character that's just after point (that is, the
280: character under the cursor). If point is at the end of a line, the
281: line separator is deleted and the next line is joined with the current
282: one.
283: .dc "delete-other-windows" "C-X 1"
284: This deletes all the other windows except the current one. This can be
285: thought of as going back into One Window mode.
286: .dc "delete-previous-character" "Rubout"
287: This deletes the character that's just before point (that is, the
288: character before the cursor). If point is at the beginning of the
289: line, the line separator is deleted and that line is joined with the
290: previous one.
291: .dc "delete-white-space" "ESC \\\\"
292: This deletes all the Tabs and Spaces around point.
293: .dc "delete-current-window" "C-X D"
294: This deletes the current window and moves point into one of the
295: remaining ones. It is an error to try to delete the only remaining
296: window.
297: .dc "describe-bindings" "Not Bound"
298: This types out a list containing each bound key and the command that gets
299: invoked every time that key is typed. To make a wall chart of \s-2JOVE\s0
300: commands, set
301: .IQ send-typeout-to-buffer
302: to "on" and \s-2JOVE\s0 will
303: store the key bindings in a buffer which you can save to a file and then
304: print.
305: .dc "describe-command" "Not Bound"
306: This prints some info on a specified command.
307: .dc "describe-key" "Not Bound"
308: This waits for you to type a key and then tells the name of the
309: command that gets invoked every time that key is hit. Once you have
310: the name of the command you can use the
311: .IQ describe-command
312: command
313: to find out exactly what it does.
314: .dc "describe-variable" "Not Bound"
315: This prints some info on a specified variable.
316: .dc "digit" "ESC [0-9]"
317: This reads a numeric argument. When you type "ESC" followed by a
318: number, "digit" keeps reading numbers until you type some other
319: command. Then that command is executes with the numeric argument you
320: specified.
321: .dc "digit-1" "Not Bound"
322: This pretends you typed "ESC 1". This is useful for terminals that
323: have keypads that send special sequences for numbers typed on the
324: keypad as opposed to numbers typed from the keyboard. This can save
325: having type "ESC" when you want to specify an argument.
326: .dc "digit-2" "Not Bound"
327: This pretends you typed "ESC 2". This is useful for terminals that
328: have keypads that send special sequences for numbers typed on the
329: keypad as opposed to numbers typed from the keyboard. This can save
330: having type "ESC" when you want to specify an argument.
331: .dc "digit-3" "Not Bound"
332: This pretends you typed "ESC 3". This is useful for terminals that
333: have keypads that send special sequences for numbers typed on the
334: keypad as opposed to numbers typed from the keyboard. This can save
335: having type "ESC" when you want to specify an argument.
336: .dc "digit-4" "Not Bound"
337: This pretends you typed "ESC 4". This is useful for terminals that
338: have keypads that send special sequences for numbers typed on the
339: keypad as opposed to numbers typed from the keyboard. This can save
340: having type "ESC" when you want to specify an argument.
341: .dc "digit-5" "Not Bound"
342: This pretends you typed "ESC 5". This is useful for terminals that
343: have keypads that send special sequences for numbers typed on the
344: keypad as opposed to numbers typed from the keyboard. This can save
345: having type "ESC" when you want to specify an argument.
346: .dc "digit-6" "Not Bound"
347: This pretends you typed "ESC 6". This is useful for terminals that
348: have keypads that send special sequences for numbers typed on the
349: keypad as opposed to numbers typed from the keyboard. This can save
350: having type "ESC" when you want to specify an argument.
351: .dc "digit-7" "Not Bound"
352: This pretends you typed "ESC 7". This is useful for terminals that
353: have keypads that send special sequences for numbers typed on the
354: keypad as opposed to numbers typed from the keyboard. This can save
355: having type "ESC" when you want to specify an argument.
356: .dc "digit-8" "Not Bound"
357: This pretends you typed "ESC 8". This is useful for terminals that
358: have keypads that send special sequences for numbers typed on the
359: keypad as opposed to numbers typed from the keyboard. This can save
360: having type "ESC" when you want to specify an argument.
361: .dc "digit-9" "Not Bound"
362: This pretends you typed "ESC 9". This is useful for terminals that
363: have keypads that send special sequences for numbers typed on the
364: keypad as opposed to numbers typed from the keyboard. This can save
365: having type "ESC" when you want to specify an argument.
366: .dc "digit-0" "Not Bound"
367: This pretends you typed "ESC 0". This is useful for terminals that
368: have keypads that send special sequences for numbers typed on the
369: keypad as opposed to numbers typed from the keyboard. This can save
370: having type "ESC" when you want to specify an argument.
371: .dc "dirs" "Not Bound"
372: This prints out the directory stack. See the "cd", "pushd", "popd"
373: commands for more info.
374: .dc "disable-biff" "(variable)"
375: When this is set, \s-2JOVE\s0 disables biff when you're editing and enables it
376: again when you get out of \s-2JOVE\s0, or when you pause to the parent shell
377: or push to a new shell. (This means arrival of new mail will not be
378: immediately apparent but will not cause indiscriminate writing on the
379: display). The default is "off".
380: .dc "dstop-process" "Not Bound"
381: Send the "dsusp" character to the current process. This is the
382: character that suspends a process on the next read from the
383: terminal. Most people have it set to C-Y. This only works if
384: you have the interactive process feature, and if you are in a
385: buffer bound to a process.
386: .dc "edit-word-abbrevs" "Not Bound"
387: This creates a buffer with a list of each abbreviation and the phrase
388: it expands into, and enters a recursive edit to let you change the
389: abbreviations or add some more. The format of this list is
390: "abbreviation:phrase" so if you add some more you should follow that
391: format. It's probably simplest just to copy some already existing
392: abbreviations and edit them. When you are done you type "C-X C-C" to
393: exit the recursive edit.
394: .dc "end-of-file" "ESC >"
395: This moves point forward to the end of the buffer. This sometimes
396: prints the "Point Pushed" message. If the end of the buffer isn't on
397: the screen \s-2JOVE\s0 will set the mark so you can go back to where you were
398: if you want.
399: .dc "end-of-line" "C-E"
400: This moves point to the end of the current line. If the line is too
401: long to fit on the screen \s-2JOVE\s0 will scroll the line to the left to
402: make the end of the line visible. The line will slide back to its
403: normal position when you move backward past the leftmost visible character
404: or when you move off the line altogether.
405: .dc "end-of-window" "ESC ."
406: This moves point to the last character in the window.
407: .dc "eof-process" "Not Bound"
408: Sends EOF to the current interactive process. This only works on
409: versions of \s-2JOVE\s0 which run under 4.2-3 BSD VAX UNIX. You can't send
410: EOF to processes on the 2.9 BSD PDP-11 UNIX.
411: .dc "erase-buffer" "Not Bound"
412: This erases the contents of the specified buffer. This is like
413: .IQ delete-buffer
414: except it only erases the contents of the buffer, not
415: the buffer itself. If you try to erase a buffer that needs saving you
416: will be asked to confirm it.
417: .dc "error-window-size" "(variable)"
418: This is the percentage of the screen to use for the error-window on the
419: screen. When you execute
420: .IQ compile-it,
421: .IQ error-window-size
422: percent of the screen will go to the error window. If the window already
423: exists and is a different size, it is made to be this size. The default
424: value is 20%.
425: .dc "exchange-point-and-mark" "C-X C-X"
426: This moves point to mark and makes mark the old point. This is for
427: quickly moving from one end of the region to another.
428: .dc "execute-named-command" "ESC X"
429: This is the way to execute a command that isn't bound to any key.
430: When you are prompted with ": " you can type the name of the
431: command. You don't have to type the entire name. Once the command
432: is unambiguous you can type Space and \s-2JOVE\s0 will fill in the rest for
433: you.
434: If you are not sure of the name of the command, type "?" and \s-2JOVE\s0
435: will print a list of all the commands that you could possibly match
436: given what you've already typed. If you don't have any idea what the
437: command's name is but you know it has something to do with windows
438: (for example), you can do "ESC X apropos window" and \s-2JOVE\s0 will print a
439: list of all the commands that are related to windows.
440: If you find yourself constantly executing the same commands this way
441: you probably want to bind them to keys so that you can execute them
442: more quickly. See the
443: .IQ bind-to-key
444: command.
445: .dc "execute-keyboard-macro" "C-X E"
446: This executes the keyboard macro. If you supply a numeric argument the
447: macro is executed that many times.
448: .dc "execute-macro" "Not Bound"
449: This executes a specified macro. If you supply a numeric argument the
450: macro is executed that many times.
451: .dc "exit-jove" "C-X C-C"
452: This exits \s-2JOVE\s0. If any buffers need saving \s-2JOVE\s0 will print a warning
453: message and ask for confirmation. If you leave without saving your
454: buffers all your work will be lost. If you made a mistake and really
455: do want to exit then you can. If you are in a recursive editing level
456: .IQ exit-jove
457: will return you from that.
458: .dc "file-creation-mode" "(variable)"
459: This variable has an octal value.
460: It contains the mode (see
461: .IQ chmod(1)
462: ) with which files should be created. This mode gets modified by your
463: current umask setting (see
464: .IQ umask(1)
465: ). The default value is usually
466: .IQ 0666
467: or
468: .IQ 0644.
469: .dc "files-should-end-with-newline" "(variable)"
470: This variable indicates that all files should always have a newline
471: at the end. This is often necessary for line printers and the like.
472: When set, if \s-2JOVE\s0 is writing a file whose last character is not a
473: newline, it will add one automatically.
474: .dc "fill-comment" "Not Bound"
475: This command fills in your C comments to make them pretty and readable.
476: This filling is done according the variable
477: .IQ comment-format.
478: .DS L
479: /*
480: * the default format makes comments like this.
481: */
482: .DE
483: This can be changed by changing the format variable. Other languages
484: may be supported by changing the format variable appropriately. The
485: formatter looks backwards from dot for an open comment symbol. If
486: found, all indentation is done relative the position of the first character
487: of the open symbol. If there is a matching close symbol, the entire
488: comment is formatted. If not, the region between dot and the open symbol
489: is reformatted.
490: .dc "fill-paragraph" "ESC J"
491: This rearranges words between lines so that all the lines in the current
492: paragraph extend as close to the right margin as possible, ensuring that
493: none of the lines will be greater than the right margin. The default value
494: for
495: .IQ right-margin
496: is 78, but can be changed with the
497: .IQ set
498: and
499: .IQ right-margin-here
500: commands. \s-2JOVE\s0 has a complicated algorithm
501: for determining the beginning and end of the paragraph. In the normal case
502: \s-2JOVE\s0 will give all the lines the same indent as they currently have,
503: but if you wish to force a new indent you can supply a numeric argument to
504: .IQ fill-paragraph
505: (e.g., by typing C-U ESC J)
506: and \s-2JOVE\s0 will indent each line to the column
507: specified by the
508: .IQ left-margin
509: variable. See also the
510: .IQ left-margin
511: variable and
512: .IQ left-margin-here
513: command.
514: .dc "fill-region" "Not Bound"
515: This is like
516: .IQ fill-paragraph,
517: except it operates on a region instead of
518: just a paragraph.
519: .dc "filter-region" "Not Bound"
520: This sends the text in the region to a UNIX command, and replaces the
521: region with the output from that command. For example, if you are
522: lazy and don't like to take the time to write properly indented C
523: code, you can put the region around your C file and
524: .IQ filter-region
525: it
526: through
527: .IQ cb,
528: the UNIX C beautifier. If you have a file that contains
529: a bunch of lines that need to be sorted you can do that from inside
530: \s-2JOVE\s0 too, by filtering the region through the
531: .IQ sort
532: UNIX command.
533: Before output from the command replaces the region \s-2JOVE\s0 stores the old
534: text in the kill ring, so if you are unhappy with the results you can
535: easily get back the old text with "C-Y".
536: .dc "find-file" "C-X C-F"
537: This visits a file into its own buffer and then selects that buffer.
538: If you've already visited this file in another buffer, that buffer is
539: selected. If the file doesn't yet exist, \s-2JOVE\s0 will print "(New file)"
540: so that you know.
541: .dc "find-tag" "C-X T"
542: This finds the file that contains the specified tag. \s-2JOVE\s0 looks up
543: tags by default in the "tags" file in the current directory. You can change
544: the default tag name by setting the
545: .IQ tag-file
546: variable to another
547: name. If you specify a numeric argument to this command, you will be
548: prompted for a tag file. This is a good way to specify another tag file
549: without changing the default. If the tag cannot be found the error is
550: reported and point stays where it is.
551: .dc "find-tag-at-point" "Not Bound"
552: This finds the file that contains the tag that point is currently on.
553: See
554: .IQ find-tag.
555: .dc "first-non-blank" "ESC M"
556: This moves point back to the indent of the current line.
557: .dc "forward-character" "C-F"
558: This moves forward over a single character. If point is at the end of
559: the line it moves to the beginning of the next one.
560: .dc "forward-paragraph" "ESC ]"
561: This moves point forward to the end of the current or next paragraph.
562: Paragraphs are bounded by lines that begin with a Period or Tab, or by blank
563: lines; a change in indentation may also signal a break between paragraphs,
564: except that \s-2JOVE\s0 allows the first line of a paragraph to be indented
565: differently from the other lines.
566: .dc "forward-s-expression" "ESC C-F"
567: This moves point forward over a s-expression. If the first significant
568: character after point is "(", this moves past the matching ")". If the
569: character begins an identifier, this moves just past it. This is mode
570: dependent, so this will move over atoms in LISP mode and C identifiers in C
571: mode. \s-2JOVE\s0 also matches "{".
572: .dc "forward-sentence" "ESC E"
573: This moves point forward to the end of the current or next sentence.
574: \s-2JOVE\s0 considers the end of a sentence to be the characters ".", "!" or
575: "?" followed by a Return, or one or more spaces.
576: .dc "forward-word" "ESC F"
577: This moves point forward to the end of the current or next word.
578: .dc "fundamental-mode" "Not Bound"
579: This sets the major mode to Fundamental. This affects what \s-2JOVE\s0
580: considers as characters that make up words. For instance,
581: Single-quote is not part of a word in Fundamental mode, but is in Text
582: mode.
583: .dc "goto-line" "ESC G"
584: If a numeric argument is supplied point moves to the beginning of that
585: line. If no argument is supplied, point remains where it is. This is
586: so you don't lose your place unintentionally, by accidentally hitting
587: the "G" instead of "F".
588: .dc "grind-s-expr" "Not Bound"
589: When point is positioned on a "(", this re-indents that LISP expression.
590: .dc "grow-window" "C-X ^"
591: This makes the current window one line bigger. This only works when
592: there is more than one window and provided there is room to change the
593: size.
594: .dc "paren-flash" ") } ]"
595: This handles the C mode curly brace indentation, the Lisp mode paren
596: indentation, and the Show Match mode paren/curly brace/square bracket
597: flashing.
598: .dc "handle-tab" "Tab"
599: This handles indenting to the "right" place in C and Lisp mode, and
600: just inserts itself in Text mode.
601: .dc "i-search-forward" "Not Bound"
602: Incremental search. Like search-forward except that instead of prompting
603: for a string and searching for that string all at once, it accepts the string
604: one character at a time. After each character you type as part of the search
605: string, it searches for the entire string so far. When you like what it
606: found, type the Return key to finish the search. You can take back a
607: character with Rubout and the search will back up to the position before
608: that character was typed. C-G aborts the search.
609: .dc "i-search-reverse" "Not Bound"
610: Incremental search. Like search-reverse except that instead of prompting
611: for a string and searching for that string all at once, it accepts the string
612: one character at a time. After each character you type as part of the search
613: string, it searches for the entire string so far. When you like what it
614: found, type the Return key to finish the search. You can take back a
615: character with Rubout and the search will back up to the position before
616: that character was typed. C-G aborts the search.
617: .dc "insert-file" "C-X C-I"
618: This inserts a specified file into the current buffer at point. Point
619: is positioned at the beginning of the inserted file.
620: .dc "internal-tabstop" "(variable)"
621: The number of spaces \s-2JOVE\s0 should print when it displays a tab character.
622: The default value is 8.
623: .dc "interrupt-process" "Not Bound"
624: This sends the interrupt character (usually C-C) to the interactive process
625: in the current buffer. This is only for versions of \s-2JOVE\s0 that have the
626: interactive processes feature. This only works when you are inside a buffer
627: that's attached to a process.
628: .dc "i-shell" "Not Bound"
629: This starts up an interactive shell in a window. \s-2JOVE\s0 uses "shell-1"
630: as the name of the buffer in which the interacting takes place. See
631: the manual for information on how to use interactive processes.
632: .dc "i-shell-command" "Not Bound"
633: This is like
634: .IQ shell-command
635: except it lets you continue with your
636: editing while the command is running. This is really useful for long
637: running commands with sporadic output. See the manual for information
638: on how to use interactive processes.
639: .dc "kill-next-word" "ESC D"
640: This kills the text from point to the end of the current or next word.
641: .dc "kill-previous-word" "ESC Rubout"
642: This kills the text from point to the beginning of the current or
643: previous word.
644: .dc "kill-process" "Not Bound"
645: This command prompts for a buffer name or buffer number (just as
646: select-buffer does) and then sends the process in that buffer a
647: kill signal (9).
648: .dc "kill-region" "C-W"
649: This deletes the text in the region and saves it on the kill ring.
650: Commands that delete text but save it on the kill ring all have the
651: word "kill" in their names. Type "C-Y" to yank back the most recent
652: kill.
653: .dc "kill-s-expression" "ESC C-K"
654: This kills the text from point to the end of the current or next
655: s-expression.
656: .dc "kill-some-buffers" "Not Bound"
657: This goes through all the existing buffers and asks whether or not to kill
658: them. If you decide to kill a buffer, and it turns out that the buffer is
659: modified, \s-2JOVE\s0 will offer to save it first. This is useful for when \s-2JOVE\s0
660: runs out of memory to store lines (this only happens on PDP-11's) and you
661: have lots of buffers that you are no longer using.
662: .dc "kill-to-beginning-of-sentence" "C-X Rubout"
663: This kills from point to the beginning of the current or previous
664: sentence.
665: .dc "kill-to-end-of-line" "C-K"
666: This kills from point to the end of the current line. When point is
667: at the end of the line the line separator is deleted and the next line
668: is joined with current one. If a numeric argument is supplied that
669: many lines are killed; if the argument is negative that many lines
670: .IQ before
671: point are killed; if the argument is zero the text from point
672: to the beginning of the line is killed.
673: .dc "kill-to-end-of-sentence" "ESC K"
674: This kills from point to the end of the current or next sentence. If a
675: negative numeric argument is supplied it kills from point to the
676: beginning of the current or previous sentence.
677: .dc "left-margin" "(variable)"
678: This is how far lines should be indented when auto-indent mode is on,
679: or when the
680: .IQ newline-and-indent
681: command is run (usually by typing
682: LineFeed). It is also used by fill-paragraph and auto-fill mode.
683: If the value is zero (the default) then the left margin is determined
684: from the surrounding lines.
685: .dc "left-margin-here" "Not Bound"
686: This sets the
687: .IQ left-margin
688: variable to the current position of
689: point. This is an easy way to say, "Make the left margin begin here,"
690: without having to count the number of spaces over it actually is.
691: .dc "lisp-mode" "Not Bound"
692: This turns on Lisp mode. Lisp mode is one of four mutually exclusive major
693: modes: Fundamental, Text, C, and Lisp. In Lisp mode, the characters Tab
694: and ) are treated specially, similar to the way they are treated in C mode.
695: Also, Auto Indent mode is affected, and handled specially.
696: .dc "list-buffers" "C-X C-B"
697: This types out a list containing various information about each buffer.
698: Right now that list looks like this:
699: .DS
700: .ta \w'NO111'u +\w'Lines1'u +\w'Scratch111'u +\w'*1'u +\w'commands.doc111'u
701: \ (* means the buffer needs saving)
702: \ NO Lines Type Name File
703: \ -- ----- ---- ---- ----
704: \ 1 1 File Main [No file]
705: \ 2 1 Scratch * Minibuf [No file]
706: \ 3 519 File * commands.doc commands.doc
707: .DE
708: The first column lists the buffer's number. When \s-2JOVE\s0 prompts for a
709: buffer name you can either type in the full name, or you can simply
710: type the buffer's number. The second column is the number of lines in
711: the buffer. The third says what type of buffer. There are four
712: types: "File", "Scratch", "Process", "I-Process". "File" is simply a
713: buffer that holds a file; "Scratch" is for buffers that \s-2JOVE\s0 uses
714: internally; "Process" is one that holds the output from a UNIX
715: command; "I-Process" is one that has an interactive process attached to
716: it. The next column contains the name of the buffer. And the last
717: column is the name of the file that's attached to the buffer. In this
718: case, both Minibuf and commands.doc have been changed but not yet
719: saved. In fact Minibuf won't be saved since it's an internal \s-2JOVE\s0
720: buffer that I don't even care about.
721: .dc "list-processes" "Not Bound"
722: This makes a list somewhat like "list-buffers" does, except its
723: list consists of the current interactive processes. Right now the list
724: looks like this:
725: .DS
726: .ta \w'shell-111111111111'u +\w'Running1111111111'u
727: \ Buffer Status Command name
728: \ ------ ------ ------- ----
729: \ shell-1 Running i-shell
730: \ fgrep Done fgrep -n Buffer *.c
731: .DE
732: The first column has the name of the buffer to which the process is
733: attached. The second has the status of the process; if a process has
734: exited normally the status is "Done" as in fgrep; if the process
735: exited with an error the status is "Exit N" where N is the value of
736: the exit code; if the process was killed by some signal the status is
737: the name of the signal that was used; otherwise the process is
738: running. The last column is the name of the command that is being run.
739: .dc "mailbox" "(variable)"
740: Set this to the full pathname of your mailbox. \s-2JOVE\s0 will look here to
741: decide whether or not you have any unread mail. This defaults to
742: /usr/spool/mail/$USER, where $USER is set to your login name.
743: .dc "mail-check-frequency" "(variable)"
744: This is how often (in seconds) \s-2JOVE\s0 should check your mailbox for
745: incoming mail. See also the
746: .IQ mailbox
747: and
748: .IQ disable-biff
749: variables.
750: .dc "make-backup-files" "(variable)"
751: If this variable is set, then whenever \s-2JOVE\s0 writes out a file, it will
752: move the previous version of the file (if there was one) to "#filename".
753: This is often convenient if you save a file by accident. The default
754: value of this variable is "off".
755: .IQ Note:
756: this is an optional part of
757: \s-2JOVE\s0, and your guru may not have it enabled, so it may not work.
758: .dc "make-buffer-unmodified" "ESC ~"
759: This makes \s-2JOVE\s0 think the selected buffer hasn't been changed even if
760: it has. Use this when you accidentally change the buffer but don't
761: want it considered changed. Watch the mode line to see the * disappear
762: when you use this command.
763: .dc "make-macro-interactive" "Not Bound"
764: This command is meaningful only while you are defining a keyboard macro.
765: Ordinarily, when a command in a macro definition requires a trailing
766: text argument (file name, search string, etc.), the argument you
767: supply becomes part of the macro definition. If you want to be able
768: to supply a different argument each time the macro is used, then while
769: you are defining it, you should give the make-macro-interactive
770: command just before typing the argument which will be used during the
771: definition process. Note: you must bind this command to a key in
772: order to use it; you can't say ESC X make-macro-interactive.
773: .dc "mark-threshold" "(variable)"
774: This variable contains the number of lines point may move by before
775: the mark is set. If, in a search or something, point moves by more
776: than this many lines, the mark is set so that you may return easily.
777: The default value of this variable is 22 (one screenful, on most
778: terminals).
779: .dc "marks-should-float" "(variable)"
780: When this variable is "off", the position of a mark is remembered as a line
781: number within the buffer and a character number within the line. If you add
782: or delete text before the mark, it will no longer point to the text you
783: marked originally because that text is no longer at the same line and
784: character number. When this variable is "on", the position of a mark is
785: adjusted to compensate for each insertion and deletion. This makes marks
786: much more sensible to use, at the cost of slowing down insertion and
787: deletion somewhat. The default value is "on".
788: .dc "match-regular-expressions" "(variable)"
789: When set, \s-2JOVE\s0 will match regular expressions in search patterns.
790: This makes special the characters ., *, [, ], ^, and $, and the two-character
791: sequences \e<, \e>, \e\|{, \e\|} and \e\||.
792: See the
793: .IQ ed(1)
794: manual page, the tutorial "Advanced Editing in
795: .UX
796: ", and the section above "Searching with Regular Expressions"
797: for more information.
798: .dc "meta-key" "(variable)"
799: You should set this variable to "on" if your terminal has a real Meta
800: key.
801: If your terminal has such a key, then a key sequence like ESC Y can
802: be entered by holding down Meta and typing Y.
803: .dc "mode-line" "(variable)"
804: The format of the mode line can be determined by setting this variable.
805: The items in the line are specified using a printf(3) format, with the
806: special things being marked as "%x". Digits may be used between the
807: '%' and the 'x' to mean repeat that many times.
808: \&'x' may be:
809: .DS I
810: .ta .5i 1i 1.5i
811: C check for new mail, and displays "[New mail]" if there
812: is any (see also the mail-check-interval and disable-biff
813: variables)
814: F the current file name, with leading path stripped
815: M the current list of major and minor modes
816: b the current buffer name
817: c the fill character (-)
818: d the current directory
819: e end of string--this must be the last item in the string
820: f the current file name
821: l the current load average (updated automatically)
822: m the buffer-modified symbol (*)
823: n the current buffer number
824: s space, but only if previous character is not a space
825: t the current time (updated automatically)
826: [ ] the square brackets printed when in a recursive edit
827: ( ) items enclosed in %( ... %) will only be printed on
828: the bottom mode line, rather than copied when the
829: window is split
830: .DE
831: In addition, any other character is simply copied into the mode line.
832: Characters may be escaped with a backslash. To get a feel for all
833: this, try typing "ESC X print mode-line" and compare the result with
834: your current mode line.
835: .dc "mode-line-should-standout" "(variable)"
836: If set, the mode line will be printed in reverse video, if your
837: terminal supports it. The default for this variable is "off".
838: .dc "name-keyboard-macro" "Not Bound"
839: This copies the keyboard macro and gives it a name freeing up the
840: keyboard macro so you can define some more. Keyboard macros with
841: their own names can be bound to keys just like built in commands
842: can. See the
843: .IQ read-macros-file-file
844: and
845: .IQ write-macros-to-file
846: commands.
847: .dc "newline" "Return"
848: This divides the current line at point moving all the text to the
849: right of point down onto the newly created line. Point moves down to
850: the beginning of the new line.
851: .dc "newline-and-backup" "C-O"
852: This divides the current line at point moving all the text to the
853: right of point down onto the newly created line. The difference
854: between this and "newline" is that point does not move down to the
855: beginning of the new line.
856: .dc "newline-and-indent" "LineFeed"
857: This behaves the same was as Return does when in Auto Indent mode.
858: This makes Auto Indent mode obsolete but it remains in the name of
859: backward compatibility.
860: .dc "next-error" "C-X C-N"
861: This moves to the next error in the list of errors that were parsed
862: with
863: .IQ parse-errors
864: or
865: .IQ parse-special-errors.
866: In one window the list
867: of errors is shown with the current one always at the top. In another
868: window is the file that contains the error. Point is positioned in
869: this window on the line where the error occurred.
870: .dc "next-line" "C-N"
871: This moves down to the next line.
872: .dc "next-page" "C-V"
873: This displays the next page of the buffer by taking the bottom line of
874: the window and redrawing the window with it at the top. If there isn't
875: another page in the buffer \s-2JOVE\s0 rings the bell. If a numeric argument
876: is supplied the screen is scrolled up that many lines; if the argument
877: is negative the screen is scrolled down.
878: .dc "next-window" "C-X N"
879: This moves into the next window. Windows live in a circular list so
880: when you're in the bottom window and you try to move to the next one
881: you are moved to the top window. It is an error to use this command
882: with only one window.
883: .dc "number-lines-in-window" "Not Bound"
884: This displays the line numbers for each line in the buffer being
885: displayed. The number isn't actually part of the text; it's just
886: printed before the actual buffer line is. To turn this off you run
887: the command again; it toggles.
888: .dc "over-write-mode" "Not Bound"
889: This turns Over Write mode on (or off if it's currently on) in the selected
890: buffer. When on, this mode changes the way the self-inserting characters
891: work. Instead of inserting themselves and pushing the rest of the line over
892: to the right, they replace or over-write the existing character. Also,
893: Rubout replaces the character before point with a space instead of deleting
894: it. When Over Write mode is on "OvrWt" is displayed on the mode line.
895: .dc "page-next-window" "ESC C-V"
896: This displays the next page in the next window. This is exactly the
897: same as "C-X N C-V C-X P".
898: .dc "paren-flash-delay" "(variable)"
899: How long, in tenths of seconds, \s-2JOVE\s0 should pause on a matching
900: parenthesis in
901: .IQ Show Match
902: mode. The default is 5.
903: .dc "parse-errors" "Not Bound"
904: This takes the list of C compilation errors (or output from another program
905: in the same format) in the current buffer and parses them for use with the
906: .IQ next-error
907: and
908: .IQ previous-error
909: and
910: .IQ current-error
911: commands.
912: This is a very useful tool and helps with compiling C programs and when used
913: in conjunction with the "grep" UNIX command very helpful in making changes
914: to a bunch of files. This command understands errors produced by cc, cpp,
915: and lint; plus any other program with the same format (e.g., "grep -n").
916: \s-2JOVE\s0 visits each file that has an error and remembers each line that
917: contains an error. It doesn't matter if later you insert or delete
918: some lines in the buffers containing errors; \s-2JOVE\s0 remembers where
919: they are regardless.
920: .IQ next-error
921: is automatically executed after one
922: of the parse commands, so you end up at the first error.
923: .dc "parse-special-errors" "Not Bound"
924: This parses errors in an unknown format. Error parsing works with
925: regular expression search strings with \\('s around the the file name
926: and the line number. So, you can use
927: .IQ parse-special-errors
928: to parse
929: lines that are in a slightly different format by typing in your own
930: search string. If you don't know how to use regular expressions you
931: can't use this command.
932: .dc "parse-spelling-errors-in-buffer" "Not Bound"
933: This parses a list of words in the current buffer and looks them up in
934: another buffer that you specify. This will probably go away soon.
935: .dc "pause-jove" "ESC S"
936: This stops \s-2JOVE\s0 and returns control to the parent shell. This
937: only works for users using the C-shell, and on systems that have the
938: job control facility. To return to \s-2JOVE\s0 you type "fg" to the C-shell.
939: .dc "physical-tabstop" "(variable)"
940: How many spaces your terminal prints when it prints a tab character.
941: .dc "pop-mark" "Not Bound"
942: This gets executed when you run
943: .IQ set-mark
944: with a numeric argument.
945: \s-2JOVE\s0 remembers the last 16 marks and you use
946: .IQ pop-mark
947: to go
948: backward through the ring of marks. If you execute "
949: .IQ pop-mark
950: enough
951: times you will eventually get back to where you started.
952: .dc "popd" "Not Bound"
953: This pops one entry off the directory stack. Entries are pushed with
954: the
955: .IQ pushd
956: command. The names were stolen from the C-shell and the
957: behavior is the same.
958: .dc "previous-error" "C-X C-P"
959: This is the same as
960: .IQ next-error
961: except it goes to the previous error.
962: See
963: .IQ next-error
964: for documentation.
965: .dc "previous-line" "C-P"
966: This moves up to the previous line.
967: .dc "previous-page" "ESC V"
968: This displays the previous page of the current buffer by taking the top
969: line and redrawing the window with it at the bottom. If a numeric
970: argument is supplied the screen is scrolled down that many lines; if
971: the argument is negative the screen is scrolled up.
972: .dc "previous-window" "C-X P and C-X O"
973: This moves into the next window. Windows live in a circular list so
974: when you're in the top window and you try to move to the previous one
975: you are moved to the bottom window. It is an error to use this command
976: with only one window.
977: .dc "print" "Not Bound"
978: This prints the value of a \s-2JOVE\s0 variable.
979: .dc "print-message" "Not Bound"
980: This command prompts for a message, and then prints it on the bottom
981: line where \s-2JOVE\s0 messages are printed.
982: .dc "process-bind-to-key" "Not Bound"
983: This command is identical to bind-to-key, except that it only affects
984: your bindings when you are in a buffer attached to a process. When
985: you enter the process buffer, any keys bound with this command will
986: automatically take their new values. When you switch to a non-process
987: buffer, the old bindings for those keys will be restored. For example,
988: you might want to execute
989: .DS I
990: process-bind-to-key stop-process ^Z
991: process-bind-to-key interrupt-process ^C
992: .DE
993: Then, when you start up an interactive process and switch into that
994: buffer, C-Z will execute stop-process and C-C will execute interrupt-
995: process. When you switch back to a non-process buffer, C-Z will go
996: back to executing scroll-up (or whatever you have it bound to).
997: .dc "process-newline" "Return"
998: This this only gets executed when in a buffer that is attached to an
999: interactive-process. \s-2JOVE\s0 does two different things depending on where
1000: you are when you hit Return. When you're at the end of the I-Process
1001: buffer this does what Return normally does, except it also makes the
1002: line available to the process. When point is positioned at some other
1003: position that line is copied to the end of the buffer (with the prompt
1004: stripped) and point is moved there with it, so you can then edit that
1005: line before sending it to the process. This command
1006: .IQ must
1007: be bound
1008: to the key you usually use to enter shell commands (Return), or else
1009: you won't be able to enter any.
1010: .dc "process-prompt" (variable)
1011: What a prompt looks like from the i-shell and i-shell-command
1012: processes. The default is "% ", the default C-shell prompt. This is
1013: actually a regular expression search string. So you can set it to be
1014: more than one thing at once using the \\| operator. For instance, for
1015: LISP hackers, the prompt can be
1016: .DS
1017: "% \\|-> \\|<[0-9]>: ".
1018: .DE
1019: .dc "push-shell" "Not Bound"
1020: This spawns a child shell and relinquishes control to it. This works
1021: on any version of UNIX, but this isn't as good as
1022: .IQ pause-jove
1023: because
1024: it takes time to start up the new shell and you get a brand new
1025: environment every time. To return to \s-2JOVE\s0 you type "C-D".
1026: .dc "pushd" "Not Bound"
1027: This pushes a directory onto the directory stack and cd's into it. It
1028: asks for the directory name but if you don't specify one it switches
1029: the top two entries no the stack. It purposely behaves the same as
1030: C-shell's
1031: .IQ pushd.
1032: .dc "pwd" "Not Bound"
1033: This prints the working directory.
1034: .dc "quadruple-numeric-argument" "C-U"
1035: This multiplies the numeric argument by 4. So, "C-U C-F" means
1036: forward 4 characters and "C-U C-U C-N" means down 16 lines.
1037: .dc "query-replace-string" "ESC Q"
1038: This replaces the occurrences of a specified string with a specified
1039: replacement string. When an occurrence is found point is moved to it
1040: and then \s-2JOVE\s0 asks what to do. The options are:
1041: .DS I
1042: .ta \w'Rubout111'u
1043: Space to replace this occurrence and go on to the next one.
1044: Period to replace this occurrence and then stop.
1045: Rubout to skip this occurrence and go on to the next one.
1046: C-R to enter a recursive edit. This lets you temporarily
1047: suspend the replace, do some editing, and then return
1048: to continue where you left off. To continue with the
1049: Query Replace type "C-X C-C" as if you were trying to
1050: exit \s-2JOVE\s0. Normally you would but when you are in a
1051: recursive edit all it does is exit that recursive
1052: editing level.
1053: C-W to delete the matched string and then enter a recursive
1054: edit.
1055: U to undo the last replacement.
1056: P or ! to go ahead and replace the remaining occurrences without
1057: asking.
1058: Return to stop the Query Replace.
1059: .DE
1060: The search for occurrences starts at point and goes to the end of the
1061: buffer, so to replace in the entire buffer you must first go to the
1062: beginning.
1063: .dc "quit-process" "Not Bound"
1064: This is the same as typing "C-\\" (the Quit character) to a normal UNIX
1065: process, except it sends it to the current process in \s-2JOVE\s0. This is
1066: only for versions of \s-2JOVE\s0 that have the interactive processes feature.
1067: This only works when you are inside a buffer that's attached to a
1068: process.
1069: .dc "quoted-insert" "C-Q"
1070: This lets you insert characters that normally would be executed as
1071: other \s-2JOVE\s0 commands. For example, to insert "C-F" you type "C-Q C-F".
1072: .dc "read-word-abbrev-file" "Not Bound"
1073: This reads a specified file that contains a bunch of abbreviation
1074: definitions, and makes those abbreviations available. If the selected
1075: buffer is not already in Word Abbrev mode this command puts it in
1076: that mode.
1077: .dc "read-macros-from-file" "Not Bound"
1078: This reads the specified file that contains a bunch of macro
1079: definitions, and defines all the macros that were currently defined
1080: when the file was created. See
1081: .IQ write-macros-to-file
1082: to see how to
1083: save macros.
1084: .dc "redraw-display" "C-L"
1085: This centers the line containing point in the window. If that line is
1086: already in the middle the window is first cleared and then redrawn.
1087: If a numeric argument is supplied, the line is positioned at that
1088: offset from the top of the window. For example, "ESC 0 C-L" positions
1089: the line containing point at the top of the window.
1090: .dc "recursive-edit" "Not Bound"
1091: This enters a recursive editing level. This isn't really very
1092: useful. I don't know why it's available for public use. I think I'll
1093: delete it some day.
1094: .dc "rename-buffer" "Not Bound"
1095: This lets you rename the current buffer.
1096: .dc "replace-in-region" "Not Bound"
1097: This is the same as
1098: .IQ replace-string
1099: except that it is restricted
1100: to occurrences between Point and Mark.
1101: .dc "replace-string" "ESC R"
1102: This replaces all occurrences of a specified string with a specified
1103: replacement string. This is just like
1104: .IQ query-replace-string
1105: except
1106: it replaces without asking.
1107: .dc "right-margin" "(variable)"
1108: Where the right margin is for
1109: .IQ "Auto Fill"
1110: mode and the
1111: .IQ justify-paragraph
1112: and
1113: .IQ justify-region
1114: commands. The default is 78.
1115: .dc "right-margin-here" "Not Bound"
1116: This sets the
1117: .IQ right-margin
1118: variable to the current position of
1119: point. This is an easy way to say, "Make the right margin begin here,"
1120: without having to count the number of spaces over it actually is.
1121: .dc "save-file" "C-X C-S"
1122: This saves the current buffer to the associated file. This makes your
1123: changes permanent so you should be sure you really want to. If the
1124: buffer has not been modified
1125: .IQ save-file
1126: refuses to do the save. If
1127: you really do want to write the file you can use "C-X C-W" which
1128: executes
1129: .IQ write-file.
1130: .dc "scroll-down" "ESC Z"
1131: This scrolls the screen one line down. If the line containing point
1132: moves past the bottom of the window point is moved up to the center of
1133: the window. If a numeric argument is supplied that many lines are
1134: scrolled; if the argument is negative the screen is scrolled up
1135: instead.
1136: .dc "scroll-step" "(variable)"
1137: How many lines should be scrolled if the
1138: .IQ previous-line
1139: or
1140: .IQ next-line
1141: commands move you off the top or bottom of the screen. You
1142: may wish to decrease this variable if you are on a slow terminal.
1143: .dc "scroll-up" "C-Z"
1144: This scrolls the screen one line up. If the line containing point
1145: moves past the top of the window point is moved down to the center of
1146: the window. If a numeric argument is supplied that many lines are
1147: scrolled; if the argument is negative the screen is scrolled down
1148: instead.
1149: .dc "search-exit-char" "(variable)"
1150: Set this to the character you want to use to exit incremental search.
1151: The default is Newline, which makes i-search compatible with normal
1152: string search.
1153: .dc "search-forward" "C-S"
1154: This searches forward for a specified search string and positions
1155: point at the end of the string if it's found. If the string is not
1156: found point remains unchanged. This searches from point to the end of
1157: the buffer, so any matches before point will be missed.
1158: .dc "search-reverse" "C-R"
1159: This searches backward for a specified search string and positions
1160: point at the beginning if the string if it's found. If the string is
1161: not found point remains unchanged. This searches from point to the
1162: beginning of the buffer, so any matches after point will be missed.
1163: .dc "select-buffer" "C-X B"
1164: This selects a new or already existing buffer making it the current
1165: one. You can type either the buffer name or number. If you type in
1166: the name you need only type the name until it is unambiguous, at which
1167: point typing Escape or Space will complete it for you. If you want to
1168: create a new buffer you can type Return instead of Space, and a new
1169: empty buffer will be created.
1170: .dc "self-insert" "Most Printing Characters"
1171: This inserts the character that invoked it into the buffer at point.
1172: Initially all but a few of the printing characters are bound to
1173: .IQ self-insert.
1174: .dc "send-typeout-to-buffer" "(variable)"
1175: When this is set \s-2JOVE\s0 will send output that normally overwrites the
1176: screen (temporarily) to a buffer instead. This affects commands like
1177: .IQ list-buffers,
1178: .IQ list-processes,
1179: and other commands that use command
1180: completion. The default value is "off".
1181: .dc "set" "Not Bound"
1182: This gives a specified variable a new value. Occasionally you'll see
1183: lines like "set this variable to that value to do this". Well, you
1184: use the
1185: .IQ set
1186: command to do that.
1187: .dc "set-mark" "C-@"
1188: This sets the mark at the current position in the buffer. It prints
1189: the message "Point pushed" on the message line. It says that instead
1190: of "Mark set" because when you set the mark the previous mark is still
1191: remembered on a ring of 16 marks. So "Point pushed" means point is
1192: pushed onto the ring of marks and becomes the value of "the mark".
1193: To go through the ring of marks you type "C-U C-@", or execute the
1194: .IQ pop-mark
1195: command. If you type this enough times you will get back
1196: to where you started.
1197: .dc "shell" "(variable)"
1198: The shell to be used with all the shell commands command. If your SHELL
1199: environment variable is set, it is used as the value of
1200: .IQ shell;
1201: otherwise "/bin/csh" is the default.
1202: .dc "shell-command" "C-X !"
1203: This runs a UNIX command and places the output from that command in a
1204: buffer. \s-2JOVE\s0 creates a buffer that matches the name of the command
1205: you specify and then attaches that buffer to a window. So, when you
1206: have only one window running this command will cause \s-2JOVE\s0 to split the
1207: window and attach the new buffer to that window. Otherwise, \s-2JOVE\s0
1208: finds the most convenient of the available windows and uses that one
1209: instead. If the buffer already exists it is first emptied, except that if
1210: it's holding a file, not some output from a previous command, \s-2JOVE\s0
1211: prints an error message and refuses to execute the command. If you
1212: really want to execute the command you should delete that buffer
1213: (saving it first, if you like) or use
1214: .IQ shell-command-to-buffer,
1215: and
1216: try again.
1217: .dc "shell-command-to-buffer" "Not Bound"
1218: This is just like
1219: .IQ shell-command
1220: except it lets you specify the
1221: buffer to use instead of \s-2JOVE\s0.
1222: .dc "shell-flags" "(variable)"
1223: This defines the flags that are passed to shell commands. The default is
1224: "-c". See the
1225: .IQ shell
1226: variable to change the default shell.
1227: .dc "show-match-mode" "Not Bound"
1228: This turns on Show Match mode (or off if it's currently on) in the
1229: selected buffer. This changes "}" and ")" so that when they are typed
1230: the are inserted as usual, and then the cursor flashes back to the
1231: matching "{" or "(" (depending on what was typed) for about half a
1232: second, and then goes back to just after the "}" or ")" that invoked
1233: the command. This is useful for typing in complicated expressions in
1234: a program. You can change how long the cursor sits on the matching
1235: paren by setting the "paren-flash-delay" variable in tenths of a
1236: second. If the matching "{" or "(" isn't visible nothing happens.
1237: .dc "shrink-window" "Not Bound"
1238: This makes the current window one line shorter, if possible. Windows
1239: must be at least 2 lines high, one for the text and the other for the
1240: mode line.
1241: .dc "source" "Not Bound"
1242: This reads a bunch of \s-2JOVE\s0 commands from a file. The format of the
1243: file is the same as that in your initialization file (your ".joverc")
1244: in your main directory. There should be one command per line and it
1245: should be as though you typed "ESC X" while in \s-2JOVE\s0. For example,
1246: here's part of my initialization file:
1247: .DS I
1248: bind-to-key i-search-reverse ^R
1249: bind-to-key i-search-forward ^S
1250: bind-to-key pause-jove ^[S
1251: .DE
1252: What they do is make "C-R" call the
1253: .IQ i-search-reverse
1254: command and
1255: "C-S" call
1256: .IQ i-search-forward
1257: and "ESC S" call
1258: .IQ pause-jove.
1259: .dc "spell-buffer" "Not Bound"
1260: This runs the current buffer through the UNIX
1261: .IQ spell
1262: program and places
1263: the output in buffer "Spell". Then \s-2JOVE\s0 lets you edit the list of
1264: words, expecting you to delete the ones that you don't care about, i.e., the
1265: ones you know are spelled correctly. Then the
1266: .IQ parse-spelling-errors-in-buffer
1267: command comes along and finds all the
1268: misspelled words and sets things up so the error commands work.
1269: .dc "split-current-window" "C-X 2"
1270: This splits the current window into two equal parts (providing the
1271: resulting windows would be big enough) and displays the selected
1272: buffer in both windows. Use "C-X 1" to go back to 1 window mode.
1273: .dc "start-remembering" "C-X ("
1274: This starts remembering your key strokes in the Keyboard macro. To
1275: stop remembering you type "C-X )". Because of a bug in \s-2JOVE\s0 you can't
1276: stop remembering by typing "ESC X stop-remembering";
1277: .IQ stop-remembering
1278: must be bound to "C-X )" in order to make things work correctly. To
1279: execute the remembered key strokes you type "C-X E" which runs the
1280: .IQ execute-keyboard-macro
1281: command.
1282: Sometimes you may want a macro to accept different input each time it runs.
1283: To see how to do this, see the
1284: .IQ make-macro-interactive
1285: command.
1286: .dc "stop-process" "Not Bound"
1287: This sends a stop signal (C-Z, for most people) to the current process.
1288: It only works if you have the interactive process feature, and you are
1289: in a buffer attached to a process.
1290: .dc "stop-remembering" "C-X )"
1291: This stop the definition of the keyboard macro. Because of a bug in
1292: \s-2JOVE\s0, this must be bound to "C-X )". Anything else will not work
1293: properly.
1294: .dc "string-length" "Not Bound"
1295: This prints the number of characters in the string that point sits in.
1296: Strings are surrounded by double quotes. \s-2JOVE\s0 knows that "\\007" is
1297: considered a single character, namely "C-G", and also knows about
1298: other common ones, like "\\r" (Return) and "\\n" (LineFeed). This is
1299: mostly useful only for C programmers.
1300: .dc "suspend-jove" "ESC S"
1301: This is a synonym for
1302: .IQ pause-jove.
1303: .dc "sync-frequency" "(variable)"
1304: The temporary files used by \s-2JOVE\s0 are forced out to disk every
1305: .IQ sync-frequency
1306: modifications. The default is 50, which really makes
1307: good sense. Unless your system is very unstable, you probably
1308: shouldn't fool with this.
1309: .dc "tag-file" "(variable)"
1310: This the name of the file in which \s-2JOVE\s0 should look up tag
1311: definitions. The default value is "./tags".
1312: .dc "text-mode" "Not Bound"
1313: This sets the major mode to Text. Currently the other modes are
1314: Fundamental, C and Lisp mode.
1315: .dc "transpose-characters" "C-T"
1316: This switches the character before point with the one after point, and
1317: then moves forward one. This doesn't work at the beginning of the
1318: line, and at the end of the line it switches the two characters before
1319: point. Since point is moved forward, so that the character that was
1320: before point is still before point, you can use "C-T" to drag a
1321: character down the length of a line. This command pretty quickly
1322: becomes very useful.
1323: .dc "transpose-lines" "C-X C-T"
1324: This switches the current line with the one above it, and then moves
1325: down one so that the line that was above point is still above point.
1326: This, like
1327: .IQ transpose-characters,
1328: can be used to drag a line down a page.
1329: .dc "unbind-key" "Not Bound"
1330: Use this to unbind
1331: .IQ any
1332: key sequence. You can use this to unbind even a
1333: prefix command, since this command does not use "key-map completion". For
1334: example, "ESC X unbind-key ESC [" unbinds the sequence "ESC [". This is
1335: useful for "turning off" something set in the system-wide ".joverc" file.
1336: .dc "update-time-frequency" "(variable)"
1337: How often the mode line is updated (and thus the time and load
1338: average, if you display them). The default is 30 seconds.
1339: .dc "use-i/d-char" "(variable)"
1340: If your terminal has insert/delete character capability you can tell \s-2JOVE\s0
1341: not to use it by setting this to "off". In my opinion it is only worth using
1342: insert/delete character at low baud rates. WARNING: if you set this to
1343: "on" when your terminal doesn't have insert/delete character capability,
1344: you will get weird (perhaps fatal) results.
1345: .dc "version" "Not Bound"
1346: Displays the version number of this \s-2JOVE\s0.
1347: .dc "visible-bell" "(variable)"
1348: Use the terminal's visible bell instead of beeping. This is set
1349: automatically if your terminal has the capability.
1350: .dc "visible-spaces-in-window" "Not Bound"
1351: This displays an underscore character instead of each space in the
1352: window and displays a greater-than followed by spaces for each tab
1353: in the window. The actual text in the buffer is not changed; only
1354: the screen display is affected. To turn this off you run the command
1355: again; it toggles.
1356: .dc "visit-file" "C-X C-V"
1357: This reads a specified file into the current buffer replacing the old
1358: text. If the buffer needs saving \s-2JOVE\s0 will offer to save it for you.
1359: Sometimes you use this to start over, say if you make lots of changes
1360: and then change your mind. If that's the case you don't want \s-2JOVE\s0 to
1361: save your buffer and you answer "NO" to the question.
1362: .dc "window-find" "C-X 4"
1363: This lets you select another buffer in another window three
1364: different ways. This waits for another character which can be one of
1365: the following:
1366: .DS I
1367: .ta .5i 1i 1.5i
1368: T Finds a tag in the other window.
1369: F Finds a file in the other window.
1370: B Selects a buffer in the other window.
1371: .DE
1372: This is just a convenient short hand for "C-X 2" (or "C-X O" if there are
1373: already two windows) followed by the appropriate sequence for invoking each
1374: command. With this, though, there isn't the extra overhead of having to
1375: redisplay. In addition, you don't have to decide whether to type "C-X 2" or
1376: "C-X O" since "C-X 4" does the right thing.
1377: .dc "word-abbrev-mode" "Not Bound"
1378: This turns on Word Abbrev mode (or off if it's currently on) in the
1379: selected buffer. Word Abbrev mode lets you specify a word (an
1380: abbreviation) and a phrase with which \s-2JOVE\s0 should substitute the
1381: abbreviation. You can use this to define words to expand into long
1382: phrases, e.g., "jove" can expand into "Jonathan's Own Version of
1383: Emacs"; another common use is defining words that you often misspell
1384: in the same way, e.g., "thier" => "their" or "teh" => "the". See
1385: the information on the
1386: .IQ auto-case-abbrev
1387: variable.
1388: .sp 1
1389: There are two kinds of abbreviations: mode specific and global. If
1390: you define a Mode specific abbreviation in C mode, it will expand only
1391: in buffers that are in C mode. This is so you can have the same
1392: abbreviation expand to different things depending on your context.
1393: Global abbreviations expand regardless of the major mode of the
1394: buffer. The way it works is this: \s-2JOVE\s0 looks first in the mode
1395: specific table, and then in the global table. Whichever it finds it
1396: in first is the one that's used in the expansion. If it doesn't find
1397: the word it is left untouched.
1398: \s-2JOVE\s0 tries to expand words as they are typed, when you type a
1399: punctuation character or Space or Return. If you are in Auto Fill
1400: mode the expansion will be filled as if you typed it yourself.
1401: .dc "wrap-search" "(variable)"
1402: If set, searches will "wrap around" the ends of the buffer instead
1403: of stopping at the bottom or top. The default is "off".
1404: .dc "write-files-on-make" "(variable)"
1405: When set, all modified files will be written out before calling
1406: make when the
1407: .IQ compile-it
1408: command is executed. The default is "on".
1409: .dc "write-word-abbrev-file" "Not Bound"
1410: This writes the currently defined abbreviations to a specified file.
1411: They can be read back in and automatically defined with
1412: .IQ read-word-abbrev-file.
1413: .dc "write-file" "C-X C-W"
1414: This saves the current buffer to a specified file, and then makes that
1415: file the default file name for this buffer. If you specify a file
1416: that already exists you are asked to confirm over-writing it.
1417: .dc "write-macros-to-file" "Not Bound"
1418: This writes the currently defined macros to a specified file. The
1419: macros can be read back in with
1420: .IQ read-macros-from-file
1421: so you can
1422: define macros and still use them in other instantiations of \s-2JOVE\s0.
1423: .dc "write-modified-files" "C-X C-M"
1424: This saves all the buffers that need saving. If you supply a numeric
1425: argument it asks for each buffer whether you really want to save it.
1426: .dc "write-region" "Not Bound"
1427: This writes the text in the region to a specified file. If the file
1428: already exists you are asked to confirm over-writing it.
1429: .dc "yank" "C-Y"
1430: This undoes the last kill command. That is, it inserts the killed
1431: text at point. When you do multiple kill commands in a row, they are
1432: merged so that yanking them back with "C\-Y" yanks back all of them.
1433: .dc "yank-pop" "ESC Y"
1434: This yanks back previous killed text. \s-2JOVE\s0 has a kill ring on which
1435: the last 10 kills are stored.
1436: .IQ Yank
1437: yanks a copy of the text at the
1438: front of the ring. If you want one of the last ten kills you use "ESC
1439: Y" which rotates the ring so another different entry is now at the
1440: front. You can use "ESC Y" only immediately following a "C-Y" or
1441: another "ESC Y". If you supply a negative numeric argument the ring
1442: is rotated the other way. If you use this command enough times in a
1443: row you will eventually get back to where you started. Experiment
1444: with this. It's extremely useful.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.