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