43BSDTahoe/new/jove/doc/cmds.doc - annotate

Return to cmds.doc CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove / doc

Annotation of 43BSDTahoe/new/jove/doc/cmds.doc, revision 1.1.1.1

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

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.