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