Return to cmds.doc CVS log

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

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

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

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