Return to cmds.doc CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / jove / doc

Annotation of 43BSD/contrib/jove/doc/cmds.doc, revision 1.1

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

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