Return to cmds.doc CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove / doc

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

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