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