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