Return to jove.4 CVS log

Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 17.jove

Annotation of 43BSDReno/share/doc/usd/17.jove/jove.4, revision 1.1

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

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