v08i031: The JOVE text editor, Part12/13

[sources-request at mirror.UUCP]

Submitted by: seismo!rochester!jpayne (Jonathan Payne)
Mod.sources: Volume 8, Issue 31
Archive-name: jove/Part12

#! /bin/sh
# This is a shell archive.  Remove anything before this line,
# then unpack it by saving it in a file and typing "sh file".
# If all goes well, you will see the message "End of archive 12 (of 13)."
# Contents:  doc/jove.5
PATH=/bin:/usr/bin:/usr/ucb; export PATH
echo shar: extracting "'doc/jove.5'" '(35706 characters)'
if test -f 'doc/jove.5' ; then 
  echo shar: will not over-write existing file "'doc/jove.5'"
else
sed 's/^X//' >doc/jove.5 <<'@//E*O*F doc/jove.5//'
X.dc "list-buffers" "C-X C-B"
XThis types out a list containing various information about each buffer.
XRight now that list looks like this:
X.DS
X.ta \w'NO111'u +\w'Lines1'u +\w'Scratch111'u +\w'*1'u +\w'commands.doc111'u
X\ (* means the buffer needs saving)
X\ NO	Lines	Type		Name	File
X\ --	-----	----		----	----
X\ 1	1	File		Main	[No file]
X\ 2	1	Scratch	*	Minibuf	[No file]
X\ 3	519	File	*	commands.doc	commands.doc
X.DE
XThe first column lists the buffer's number.  When \s-2JOVE\s0 prompts for a
Xbuffer name you can either type in the full name, or you can simply
Xtype the buffer's number.  The second column is the number of lines in
Xthe buffer.  The third says what type of buffer.  There are four
Xtypes: "File", "Scratch", "Process", "I-Process".  "File" is simply a
Xbuffer that holds a file; "Scratch" is for buffers that \s-2JOVE\s0 uses
Xinternally; "Process" is one that holds the output from a UNIX
Xcommand; "I-Process" is one that has an interactive process attached to
Xit.  The next column contains the name of the buffer.  And the last
Xcolumn is the name of the file that's attached to the buffer.  In this
Xcase, both Minibuf and commands.doc have been changed but not yet
Xsaved.  In fact Minibuf won't be saved since it's an internal \s-2JOVE\s0
Xbuffer that I don't even care about.
X.dc "list-processes" "Not Bound"
XThis makes a list somewhat like "list-buffers" does, except its
Xlist consists of the current interactive processes.  Right now the list
Xlooks like this:
X.DS
X.ta \w'shell-111111111111'u +\w'Running1111111111'u
X\ Buffer	Status	Pid    Command
X\ ------	------	---    -------
X\ *shell*	Running	18415	shell
X\ fgrep 	Done	18512   fgrep -n Buffer *.c
X.DE
XThe first column has the name of the buffer to which the process is
Xattached.  The second has the status of the process; if a process has
Xexited normally the status is "Done" as in fgrep; if the process
Xexited with an error the status is "Exit N" where N is the value of
Xthe exit code; if the process was killed by some signal the status is
Xthe name of the signal that was used; otherwise the process is
Xrunning.  The last column is the name of the command that is being run.
X.dc "mailbox" "(variable)"
XSet this to the full pathname of your mailbox.  \s-2JOVE\s0 will look here to
Xdecide whether or not you have any unread mail.  This defaults to
X/usr/spool/mail/$USER, where $USER is set to your login name.
X.dc "mail-check-frequency" "(variable)"
XThis is how often (in seconds) \s-2JOVE\s0 should check your mailbox for
Xincoming mail.  See also the
X.IQ mailbox
Xand
X.IQ disable-biff
Xvariables.
X.dc "make-backup-files" "(variable)"
XIf this variable is set, then whenever \s-2JOVE\s0 writes out a file, it will
Xmove the previous version of the file (if there was one) to "#filename".
XThis is often convenient if you save a file by accident.  The default
Xvalue of this variable is "off".
X.IQ Note:
Xthis is an optional part of
X\s-2JOVE\s0, and your guru may not have it enabled, so it may not work.
X.dc "make-buffer-unmodified" "ESC ~"
XThis makes \s-2JOVE\s0 think the selected buffer hasn't been changed even if
Xit has.  Use this when you accidentally change the buffer but don't
Xwant it considered changed.  Watch the mode line to see the * disappear
Xwhen you use this command.  
X.dc "make-macro-interactive" "Not Bound"
XThis command is meaningful only while you are defining a keyboard macro.
XOrdinarily, when a command in a macro definition requires a trailing
Xtext argument (file name, search string, etc.), the argument you
Xsupply becomes part of the macro definition.  If you want to be able
Xto supply a different argument each time the macro is used, then while
Xyou are defining it, you should give the make-macro-interactive
Xcommand just before typing the argument which will be used during the
Xdefinition process.  Note: you must bind this command to a key in
Xorder to use it; you can't say ESC X make-macro-interactive.
X.dc "mark-threshold" "(variable)"
XThis variable contains the number of lines point may move by before
Xthe mark is set.  If, in a search or something, point moves by more
Xthan this many lines, the mark is set so that you may return easily.
XThe default value of this variable is 22 (one screenful, on most
Xterminals).
X.dc "marks-should-float" "(variable)"
XWhen this variable is "off", the position of a mark is remembered as a line
Xnumber within the buffer and a character number within the line.  If you add
Xor delete text before the mark, it will no longer point to the text you
Xmarked originally because that text is no longer at the same line and
Xcharacter number.  When this variable is "on", the position of a mark is
Xadjusted to compensate for each insertion and deletion.  This makes marks
Xmuch more sensible to use, at the cost of slowing down insertion and
Xdeletion somewhat.  The default value is "on".
X.dc "match-regular-expressions" "(variable)"
XWhen set, \s-2JOVE\s0 will match regular expressions in search patterns.
XThis makes special the characters ., *, [, ], ^, and $, and the two-character
Xsequences \e<, \e>, \e\|{, \e\|} and \e\||.
XSee the
X.IQ ed(1)
Xmanual page, the tutorial "Advanced Editing in 
X.UX
X", and the section above "Searching with Regular Expressions"
Xfor more information.
X.dc "meta-key" "(variable)"
XYou should set this variable to "on" if your terminal has a real Meta
Xkey.
XIf your terminal has such a key, then a key sequence like ESC Y can
Xbe entered by holding down Meta and typing Y.
X.dc "mode-line" "(variable)"
XThe format of the mode line can be determined by setting this variable.
XThe items in the line are specified using a printf(3) format, with the
Xspecial things being marked as "%x".  Digits may be used between the
X'%' and the 'x' to mean repeat that many times.
X\&'x' may be:
X.DS I
X.ta .5i 1i 1.5i
X	C	check for new mail, and displays "[New mail]" if there
X		is any (see also the mail-check-interval and disable-biff
X		variables)
X	F	the current file name, with leading path stripped
X	M	the current list of major and minor modes
X	b	the current buffer name
X	c	the fill character (-)
X	d	the current directory
X	e	end of string--this must be the last item in the string
X	f	the current file name
X	l	the current load average (updated automatically)
X	mxy	x, when the buffer is modified or y, when not
X	n	the current buffer number
X	s	space, but only if previous character is not a space
X	t	the current time (updated automatically)
X	[ ]	the square brackets printed when in a recursive edit
X	( )	items enclosed in %( ... %) will only be printed on
X		the bottom mode line, rather than copied when the
X		window is split
X.DE
XIn addition, any other character is simply copied into the mode line.
XCharacters may be escaped with a backslash.  To get a feel for all
Xthis, try typing "ESC X print mode-line" and compare the result with
Xyour current mode line.
X.dc "mode-line-should-standout" "(variable)"
XIf set, the mode line will be printed in reverse video, if your
Xterminal supports it.  The default for this variable is "off".
X.dc "name-keyboard-macro" "Not Bound"
XThis copies the keyboard macro and gives it a name freeing up the
Xkeyboard macro so you can define some more.  Keyboard macros with
Xtheir own names can be bound to keys just like built in commands
Xcan.  See the
X.IQ read-macros-from-file
Xand
X.IQ write-macros-to-file
Xcommands.
X.dc "newline" "Return"
XThis divides the current line at point moving all the text to the
Xright of point down onto the newly created line.  Point moves down to
Xthe beginning of the new line.
X.dc "newline-and-backup" "C-O"
XThis divides the current line at point moving all the text to the
Xright of point down onto the newly created line.  The difference
Xbetween this and "newline" is that point does not move down to the
Xbeginning of the new line.
X.dc "newline-and-indent" "LineFeed"
XThis behaves the same was as Return does when in Auto Indent mode.
XThis makes Auto Indent mode obsolete but it remains in the name of
Xbackward compatibility.
X.dc "next-error" "C-X C-N"
XThis moves to the next error in the list of errors that were parsed
Xwith
X.IQ parse-errors
Xor
X.IQ parse-special-errors.
XIn one window the list
Xof errors is shown with the current one always at the top.  In another
Xwindow is the file that contains the error.  Point is positioned in
Xthis window on the line where the error occurred.
X.dc "next-line" "C-N"
XThis moves down to the next line.
X.dc "next-page" "C-V"
XThis displays the next page of the buffer by taking the bottom line of
Xthe window and redrawing the window with it at the top.  If there isn't
Xanother page in the buffer \s-2JOVE\s0 rings the bell.  If a numeric argument
Xis supplied the screen is scrolled up that many lines; if the argument
Xis negative the screen is scrolled down.
X.dc "next-window" "C-X N"
XThis moves into the next window.  Windows live in a circular list so
Xwhen you're in the bottom window and you try to move to the next one
Xyou are moved to the top window.  It is an error to use this command
Xwith only one window.
X.dc "number-lines-in-window" "Not Bound"
XThis displays the line numbers for each line in the buffer being
Xdisplayed.  The number isn't actually part of the text; it's just
Xprinted before the actual buffer line is.  To turn this off you run
Xthe command again; it toggles.
X.dc "over-write-mode" "Not Bound"
XThis turns Over Write mode on (or off if it's currently on) in the selected
Xbuffer.  When on, this mode changes the way the self-inserting characters
Xwork.  Instead of inserting themselves and pushing the rest of the line over
Xto the right, they replace or over-write the existing character.  Also,
XRubout replaces the character before point with a space instead of deleting
Xit.  When Over Write mode is on "OvrWt" is displayed on the mode line.
X.dc "page-next-window" "ESC C-V"
XThis displays the next page in the next window.  This is exactly the
Xsame as "C-X N C-V C-X P".
X.dc "paren-flash-delay" "(variable)"
XHow long, in tenths of seconds, \s-2JOVE\s0 should pause on a matching
Xparenthesis in
X.IQ Show Match
Xmode.  The default is 5.
X.dc "parse-errors" "Not Bound"
XThis takes the list of C compilation errors (or output from another program
Xin the same format) in the current buffer and parses them for use with the
X.IQ next-error
Xand
X.IQ previous-error
Xand
X.IQ current-error
Xcommands.
XThis is a very useful tool and helps with compiling C programs and when used
Xin conjunction with the "grep" UNIX command very helpful in making changes
Xto a bunch of files.  This command understands errors produced by cc, cpp,
Xand lint; plus any other program with the same format (e.g., "grep -n").
X\s-2JOVE\s0 visits each file that has an error and remembers each line that
Xcontains an error.  It doesn't matter if later you insert or delete
Xsome lines in the buffers containing errors; \s-2JOVE\s0 remembers where
Xthey are regardless.
X.IQ next-error
Xis automatically executed after one
Xof the parse commands, so you end up at the first error.
X.dc "parse-special-errors" "Not Bound"
XThis parses errors in an unknown format.  Error parsing works with
Xregular expression search strings with \\('s around the the file name
Xand the line number.  So, you can use
X.IQ parse-special-errors
Xto parse
Xlines that are in a slightly different format by typing in your own
Xsearch string.  If you don't know how to use regular expressions you
Xcan't use this command.
X.dc "parse-spelling-errors-in-buffer" "Not Bound"
XThis parses a list of words in the current buffer and looks them up in
Xanother buffer that you specify.  This will probably go away soon.
X.dc "pause-jove" "ESC S"
XThis stops \s-2JOVE\s0 and returns control to the parent shell.  This
Xonly works for users using the C-shell, and on systems that have the
Xjob control facility.  To return to \s-2JOVE\s0 you type "fg" to the C-shell.
X.dc "physical-tabstop" "(variable)"
XHow many spaces your terminal prints when it prints a tab character.
X.dc "pop-mark" "Not Bound"
XThis gets executed when you run
X.IQ set-mark
Xwith a numeric argument.
X\s-2JOVE\s0 remembers the last 16 marks and you use
X.IQ pop-mark
Xto go
Xbackward through the ring of marks.  If you execute
X.IQ pop-mark
Xenough
Xtimes you will eventually get back to where you started.
X.dc "popd" "Not Bound"
XThis pops one entry off the directory stack.  Entries are pushed with
Xthe
X.IQ pushd
Xcommand.  The names were stolen from the C-shell and the
Xbehavior is the same.
X.dc "previous-error" "C-X C-P"
XThis is the same as
X.IQ next-error
Xexcept it goes to the previous error.
XSee
X.IQ next-error
Xfor documentation.
X.dc "previous-line" "C-P"
XThis moves up to the previous line.
X.dc "previous-page" "ESC V"
XThis displays the previous page of the current buffer by taking the top
Xline and redrawing the window with it at the bottom.  If a numeric
Xargument is supplied the screen is scrolled down that many lines; if
Xthe argument is negative the screen is scrolled up.
X.dc "previous-window" "C-X P and C-X O"
XThis moves into the next window.  Windows live in a circular list so
Xwhen you're in the top window and you try to move to the previous one
Xyou are moved to the bottom window.  It is an error to use this command
Xwith only one window.
X.dc "print" "Not Bound"
XThis prints the value of a \s-2JOVE\s0 variable.
X.dc "print-message" "Not Bound"
XThis command prompts for a message, and then prints it on the bottom
Xline where \s-2JOVE\s0 messages are printed.
X.dc "process-bind-to-key" "Not Bound"
XThis command is identical to bind-to-key, except that it only affects
Xyour bindings when you are in a buffer attached to a process.  When
Xyou enter the process buffer, any keys bound with this command will
Xautomatically take their new values.  When you switch to a non-process
Xbuffer, the old bindings for those keys will be restored.  For example,
Xyou might want to execute
X.DS I
Xprocess-bind-to-key stop-process ^Z
Xprocess-bind-to-key interrupt-process ^C
X.DE
XThen, when you start up an interactive process and switch into that
Xbuffer, C-Z will execute stop-process and C-C will execute interrupt-
Xprocess.  When you switch back to a non-process buffer, C-Z will go
Xback to executing scroll-up (or whatever you have it bound to).
X.dc "process-newline" "Return"
XThis this only gets executed when in a buffer that is attached to an
Xinteractive-process.  \s-2JOVE\s0 does two different things depending on where
Xyou are when you hit Return.  When you're at the end of the I-Process
Xbuffer this does what Return normally does, except it also makes the
Xline available to the process.  When point is positioned at some other
Xposition that line is copied to the end of the buffer (with the prompt
Xstripped) and point is moved there with it, so you can then edit that
Xline before sending it to the process.  This command
X.IQ must
Xbe bound
Xto the key you usually use to enter shell commands (Return), or else
Xyou won't be able to enter any.
X.dc "process-prompt" (variable)
XWhat a prompt looks like from the shell and i-shell-command
Xprocesses.  The default is "% ", the default C-shell prompt.  This is
Xactually a regular expression search string.  So you can set it to be
Xmore than one thing at once using the \\| operator.  For instance, for
XLISP hackers, the prompt can be
X.DS
X"% \\|-> \\|<[0-9]>: ".
X.DE
X.dc "push-shell" "Not Bound"
XThis spawns a child shell and relinquishes control to it.  This works
Xon any version of UNIX, but this isn't as good as
X.IQ pause-jove
Xbecause
Xit takes time to start up the new shell and you get a brand new
Xenvironment every time.  To return to \s-2JOVE\s0 you type "C-D".
X.dc "pushd" "Not Bound"
XThis pushes a directory onto the directory stack and cd's into it.  It
Xasks for the directory name but if you don't specify one it switches
Xthe top two entries no the stack.  It purposely behaves the same as
XC-shell's
X.IQ pushd.
X.dc "pwd" "Not Bound"
XThis prints the working directory.
X.dc "quadruple-numeric-argument" "C-U"
XThis multiplies the numeric argument by 4.  So, "C-U C-F" means
Xforward 4 characters and "C-U C-U C-N" means down 16 lines.
X.dc "query-replace-string" "ESC Q"
XThis replaces the occurrences of a specified string with a specified
Xreplacement string.  When an occurrence is found point is moved to it
Xand then \s-2JOVE\s0 asks what to do.  The options are:
X.DS I
X.ta \w'Rubout111'u
XSpace	to replace this occurrence and go on to the next one.
XPeriod	to replace this occurrence and then stop.
XRubout	to skip this occurrence and go on to the next one.
XC-R	to enter a recursive edit.  This lets you temporarily
X	suspend the replace, do some editing, and then return
X	to continue where you left off.  To continue with the
X	Query Replace type "C-X C-C" as if you were trying to
X	exit \s-2JOVE\s0.  Normally you would but when you are in a
X	recursive edit all it does is exit that recursive
X	editing level.
XC-W	to delete the matched string and then enter a recursive
X	edit.
XU	to undo the last replacement.
XP or !	to go ahead and replace the remaining occurrences without
X	asking.
XReturn	to stop the Query Replace.
X.DE
XThe search for occurrences starts at point and goes to the end of the
Xbuffer, so to replace in the entire buffer you must first go to the
Xbeginning.
X.dc "quit-process" "Not Bound"
XThis is the same as typing "C-\\" (the Quit character) to a normal UNIX
Xprocess, except it sends it to the current process in \s-2JOVE\s0.  This is
Xonly for versions of \s-2JOVE\s0 that have the interactive processes feature.
XThis only works when you are inside a buffer that's attached to a
Xprocess.
X.dc "quoted-insert" "C-Q"
XThis lets you insert characters that normally would be executed as
Xother \s-2JOVE\s0 commands.  For example, to insert "C-F" you type "C-Q C-F".
X.dc "read-word-abbrev-file" "Not Bound"
XThis reads a specified file that contains a bunch of abbreviation
Xdefinitions, and makes those abbreviations available.  If the selected
Xbuffer is not already in Word Abbrev mode this command puts it in
Xthat mode.
X.dc "read-macros-from-file" "Not Bound"
XThis reads the specified file that contains a bunch of macro
Xdefinitions, and defines all the macros that were currently defined
Xwhen the file was created.  See
X.IQ write-macros-to-file
Xto see how to
Xsave macros.
X.dc "redraw-display" "C-L"
XThis centers the line containing point in the window.  If that line is
Xalready in the middle the window is first cleared and then redrawn.
XIf a numeric argument is supplied, the line is positioned at that
Xoffset from the top of the window.  For example, "ESC 0 C-L" positions
Xthe line containing point at the top of the window.
X.dc "recursive-edit" "Not Bound"
XThis enters a recursive editing level.  This isn't really very
Xuseful.  I don't know why it's available for public use.  I think I'll
Xdelete it some day.
X.dc "rename-buffer" "Not Bound"
XThis lets you rename the current buffer.
X.dc "replace-in-region" "Not Bound"
XThis is the same as
X.IQ replace-string
Xexcept that it is restricted
Xto occurrences between Point and Mark.
X.dc "replace-string" "ESC R"
XThis replaces all occurrences of a specified string with a specified
Xreplacement string.  This is just like
X.IQ query-replace-string
Xexcept
Xit replaces without asking.
X.dc "right-margin" "(variable)"
XWhere the right margin is for
X.IQ "Auto Fill"
Xmode and the
X.IQ justify-paragraph
Xand
X.IQ justify-region
Xcommands.  The default is 78.
X.dc "right-margin-here" "Not Bound"
XThis sets the
X.IQ right-margin
Xvariable to the current position of
Xpoint.  This is an easy way to say, "Make the right margin begin here,"
Xwithout having to count the number of spaces over it actually is.
X.dc "save-file" "C-X C-S"
XThis saves the current buffer to the associated file.  This makes your
Xchanges permanent so you should be sure you really want to.  If the
Xbuffer has not been modified
X.IQ save-file
Xrefuses to do the save.  If
Xyou really do want to write the file you can use "C-X C-W" which
Xexecutes
X.IQ write-file.
X.dc "scroll-down" "ESC Z"
XThis scrolls the screen one line down.  If the line containing point
Xmoves past the bottom of the window point is moved up to the center of
Xthe window.  If a numeric argument is supplied that many lines are
Xscrolled; if the argument is negative the screen is scrolled up
Xinstead.
X.dc "scroll-step" "(variable)"
XHow many lines should be scrolled if the
X.IQ previous-line
Xor
X.IQ next-line
Xcommands move you off the top or bottom of the screen.  You
Xmay wish to decrease this variable if you are on a slow terminal.
X.dc "scroll-up" "C-Z"
XThis scrolls the screen one line up.  If the line containing point
Xmoves past the top of the window point is moved down to the center of
Xthe window.  If a numeric argument is supplied that many lines are
Xscrolled; if the argument is negative the screen is scrolled down
Xinstead.
X.dc "search-exit-char" "(variable)"
XSet this to the character you want to use to exit incremental search.
XThe default is Newline, which makes i-search compatible with normal
Xstring search.
X.dc "search-forward" "C-S"
XThis searches forward for a specified search string and positions
Xpoint at the end of the string if it's found.  If the string is not
Xfound point remains unchanged.  This searches from point to the end of
Xthe buffer, so any matches before point will be missed.
X.dc "search-reverse" "C-R"
XThis searches backward for a specified search string and positions
Xpoint at the beginning if the string if it's found.  If the string is
Xnot found point remains unchanged.  This searches from point to the
Xbeginning of the buffer, so any matches after point will be missed.
X.dc "select-buffer" "C-X B"
XThis selects a new or already existing buffer making it the current
Xone.  You can type either the buffer name or number.  If you type in
Xthe name you need only type the name until it is unambiguous, at which
Xpoint typing Escape or Space will complete it for you.  If you want to
Xcreate a new buffer you can type Return instead of Space, and a new
Xempty buffer will be created.
X.dc "self-insert" "Most Printing Characters"
XThis inserts the character that invoked it into the buffer at point.
XInitially all but a few of the printing characters are bound to
X.IQ self-insert.
X.dc "send-typeout-to-buffer" "(variable)"
XWhen this is set \s-2JOVE\s0 will send output that normally overwrites the
Xscreen (temporarily) to a buffer instead.  This affects commands like
X.IQ list-buffers,
X.IQ list-processes,
Xand other commands that use command
Xcompletion.  The default value is "off".
X.dc "set" "Not Bound"
XThis gives a specified variable a new value.  Occasionally you'll see
Xlines like "set this variable to that value to do this".  Well, you
Xuse the
X.IQ set
Xcommand to do that.
X.dc "set-mark" "C-@"
XThis sets the mark at the current position in the buffer.  It prints
Xthe message "Point pushed" on the message line.  It says that instead
Xof "Mark set" because when you set the mark the previous mark is still
Xremembered on a ring of 16 marks.  So "Point pushed" means point is
Xpushed onto the ring of marks and becomes the value of "the mark".
XTo go through the ring of marks you type "C-U C-@", or execute the
X.IQ pop-mark
Xcommand.  If you type this enough times you will get back
Xto where you started.
X.dc "shell" "(variable)"
XThe shell to be used with all the shell commands command.  If your SHELL
Xenvironment variable is set, it is used as the value of
X.IQ shell;
Xotherwise "/bin/csh" is the default.
X.dc "shell-command" "C-X !"
XThis runs a UNIX command and places the output from that command in a
Xbuffer.  \s-2JOVE\s0 creates a buffer that matches the name of the command
Xyou specify and then attaches that buffer to a window.  So, when you
Xhave only one window running this command will cause \s-2JOVE\s0 to split the
Xwindow and attach the new buffer to that window.  Otherwise, \s-2JOVE\s0
Xfinds the most convenient of the available windows and uses that one
Xinstead.  If the buffer already exists it is first emptied, except that if
Xit's holding a file, not some output from a previous command, \s-2JOVE\s0
Xprints an error message and refuses to execute the command.  If you
Xreally want to execute the command you should delete that buffer
X(saving it first, if you like) or use
X.IQ shell-command-to-buffer,
Xand
Xtry again.
X.dc "shell-command-to-buffer" "Not Bound"
XThis is just like
X.IQ shell-command
Xexcept it lets you specify the
Xbuffer to use instead of \s-2JOVE\s0.
X.dc "shell-flags" "(variable)"
XThis defines the flags that are passed to shell commands.  The default is
X"-c".  See the
X.IQ shell
Xvariable to change the default shell.
X.dc "show-match-mode" "Not Bound"
XThis turns on Show Match mode (or off if it's currently on) in the
Xselected buffer.  This changes "}" and ")" so that when they are typed
Xthe are inserted as usual, and then the cursor flashes back to the
Xmatching "{" or "(" (depending on what was typed) for about half a
Xsecond, and then goes back to just after the "}" or ")" that invoked
Xthe command.  This is useful for typing in complicated expressions in
Xa program.  You can change how long the cursor sits on the matching
Xparen by setting the "paren-flash-delay" variable in tenths of a
Xsecond.  If the matching "{" or "(" isn't visible nothing happens.
X.dc "shrink-window" "Not Bound"
XThis makes the current window one line shorter, if possible.  Windows
Xmust be at least 2 lines high, one for the text and the other for the
Xmode line.
X.dc "source" "Not Bound"
XThis reads a bunch of \s-2JOVE\s0 commands from a file.  The format of the
Xfile is the same as that in your initialization file (your ".joverc")
Xin your main directory.  There should be one command per line and it
Xshould be as though you typed "ESC X" while in \s-2JOVE\s0.  For example,
Xhere's part of my initialization file:
X.DS I
Xbind-to-key i-search-reverse ^R
Xbind-to-key i-search-forward ^S
Xbind-to-key pause-jove ^[S
X.DE
XWhat they do is make "C-R" call the
X.IQ i-search-reverse
Xcommand and
X"C-S" call
X.IQ i-search-forward
Xand "ESC S" call
X.IQ pause-jove.
X.dc "spell-buffer" "Not Bound"
XThis runs the current buffer through the UNIX
X.IQ spell
Xprogram and places
Xthe output in buffer "Spell".  Then \s-2JOVE\s0 lets you edit the list of
Xwords, expecting you to delete the ones that you don't care about, i.e., the
Xones you know are spelled correctly.  Then the
X.IQ parse-spelling-errors-in-buffer
Xcommand comes along and finds all the
Xmisspelled words and sets things up so the error commands work.
X.dc "split-current-window" "C-X 2"
XThis splits the current window into two equal parts (providing the
Xresulting windows would be big enough) and displays the selected
Xbuffer in both windows.  Use "C-X 1" to go back to 1 window mode.
X.dc "start-remembering" "C-X ("
XThis starts remembering your key strokes in the Keyboard macro.  To
Xstop remembering you type "C-X )".  Because of a bug in \s-2JOVE\s0 you can't
Xstop remembering by typing "ESC X stop-remembering";
X.IQ stop-remembering
Xmust be bound to "C-X )" in order to make things work correctly.  To
Xexecute the remembered key strokes you type "C-X E" which runs the
X.IQ execute-keyboard-macro
Xcommand.
XSometimes you may want a macro to accept different input each time it runs.
XTo see how to do this, see the
X.IQ make-macro-interactive
Xcommand.
X.dc "stop-process" "Not Bound"
XThis sends a stop signal (C-Z, for most people) to the current process.
XIt only works if you have the interactive process feature, and you are
Xin a buffer attached to a process.
X.dc "stop-remembering" "C-X )"
XThis stop the definition of the keyboard macro.  Because of a bug in
X\s-2JOVE\s0, this must be bound to "C-X )".  Anything else will not work
Xproperly.
X.dc "string-length" "Not Bound"
XThis prints the number of characters in the string that point sits in.
XStrings are surrounded by double quotes.  \s-2JOVE\s0 knows that "\\007" is
Xconsidered a single character, namely "C-G", and also knows about
Xother common ones, like "\\r" (Return) and "\\n" (LineFeed).  This is
Xmostly useful only for C programmers.
X.dc "suspend-jove" "ESC S"
XThis is a synonym for
X.IQ pause-jove.
X.dc "sync-frequency" "(variable)"
XThe temporary files used by \s-2JOVE\s0 are forced out to disk every
X.IQ sync-frequency
Xmodifications.  The default is 50, which really makes
Xgood sense.  Unless your system is very unstable, you probably
Xshouldn't fool with this.
X.dc "tag-file" "(variable)"
XThis the name of the file in which \s-2JOVE\s0 should look up tag
Xdefinitions.  The default value is "./tags".
X.dc "tmp-file-pathname" "(variable)"
XThis tells JOVE where to put the tmp files, which is where JOVE stores
Xbuffers internally.  The default is usually in /tmp, but if you want to
Xstore them somewhere else, you can set this variable.  If your system
Xcrashes a lot it might be a good idea to set this variable to somewhere
Xother than /tmp because the system removes all the files in /tmp upon
Xreboot, and so you would not be able to recover editor buffers using the
X"jove -r" command.
X
XNOTE: In order for this to work correctly you must set this variable
XBEFORE JOVE creates the tmp file.  You can set this in your .joverc (the
Xcloser to tbe beginning the better), or as soon as you start up JOVE
Xbefore you visit any files.
X.dc "text-mode" "Not Bound"
XThis sets the major mode to Text.  Currently the other modes are
XFundamental, C and Lisp mode.
X.dc "transpose-characters" "C-T"
XThis switches the character before point with the one after point, and
Xthen moves forward one.  This doesn't work at the beginning of the
Xline, and at the end of the line it switches the two characters before
Xpoint.  Since point is moved forward, so that the character that was
Xbefore point is still before point, you can use "C-T" to drag a
Xcharacter down the length of a line.  This command pretty quickly
Xbecomes very useful.
X.dc "transpose-lines" "C-X C-T"
XThis switches the current line with the one above it, and then moves
Xdown one so that the line that was above point is still above point.
XThis, like
X.IQ transpose-characters,
Xcan be used to drag a line down a page.
X.dc "unbind-key" "Not Bound"
XUse this to unbind
X.IQ any
Xkey sequence.  You can use this to unbind even a
Xprefix command, since this command does not use "key-map completion".  For
Xexample, "ESC X unbind-key ESC [" unbinds the sequence "ESC [".  This is
Xuseful for "turning off" something set in the system-wide ".joverc" file.
X.dc "update-time-frequency" "(variable)"
XHow often the mode line is updated (and thus the time and load
Xaverage, if you display them).  The default is 30 seconds.
X.dc "use-i/d-char" "(variable)"
XIf your terminal has insert/delete character capability you can tell \s-2JOVE\s0
Xnot to use it by setting this to "off".  In my opinion it is only worth using
Xinsert/delete character at low baud rates.  WARNING: if you set this to
X"on" when your terminal doesn't have insert/delete character capability,
Xyou will get weird (perhaps fatal) results.
X.dc "version" "Not Bound"
XDisplays the version number of this \s-2JOVE\s0.
X.dc "visible-bell" "(variable)"
XUse the terminal's visible bell instead of beeping.  This is set
Xautomatically if your terminal has the capability.
X.dc "visible-spaces-in-window" "Not Bound"
XThis displays an underscore character instead of each space in the
Xwindow and displays a greater-than followed by spaces for each tab
Xin the window.  The actual text in the buffer is not changed; only
Xthe screen display is affected.  To turn this off you run the command
Xagain; it toggles.
X.dc "visit-file" "C-X C-V"
XThis reads a specified file into the current buffer replacing the old
Xtext.  If the buffer needs saving \s-2JOVE\s0 will offer to save it for you.
XSometimes you use this to start over, say if you make lots of changes
Xand then change your mind.  If that's the case you don't want \s-2JOVE\s0 to
Xsave your buffer and you answer "NO" to the question.
X.dc "window-find" "C-X 4"
XThis lets you select another buffer in another window three
Xdifferent ways.  This waits for another character which can be one of
Xthe following:
X.DS I
X.ta .5i 1i 1.5i
XT	Finds a tag in the other window.
XF	Finds a file in the other window.
XB	Selects a buffer in the other window.
X.DE
XThis is just a convenient short hand for "C-X 2" (or "C-X O" if there are
Xalready two windows) followed by the appropriate sequence for invoking each
Xcommand.  With this, though, there isn't the extra overhead of having to
Xredisplay.  In addition, you don't have to decide whether to type "C-X 2" or
X"C-X O" since "C-X 4" does the right thing.
X.dc "word-abbrev-mode" "Not Bound"
XThis turns on Word Abbrev mode (or off if it's currently on) in the
Xselected buffer.  Word Abbrev mode lets you specify a word (an
Xabbreviation) and a phrase with which \s-2JOVE\s0 should substitute the
Xabbreviation.  You can use this to define words to expand into long
Xphrases, e.g., "jove" can expand into "Jonathan's Own Version of
XEmacs"; another common use is defining words that you often misspell
Xin the same way, e.g., "thier" => "their" or "teh" => "the".  See
Xthe information on the
X.IQ auto-case-abbrev
Xvariable.
X.sp 1
XThere are two kinds of abbreviations: mode specific and global.  If
Xyou define a Mode specific abbreviation in C mode, it will expand only
Xin buffers that are in C mode.  This is so you can have the same
Xabbreviation expand to different things depending on your context.
XGlobal abbreviations expand regardless of the major mode of the
Xbuffer.  The way it works is this: \s-2JOVE\s0 looks first in the mode
Xspecific table, and then in the global table.  Whichever it finds it
Xin first is the one that's used in the expansion.  If it doesn't find
Xthe word it is left untouched.
X\s-2JOVE\s0 tries to expand words as they are typed, when you type a
Xpunctuation character or Space or Return.  If you are in Auto Fill
Xmode the expansion will be filled as if you typed it yourself.
X.dc "wrap-search" "(variable)"
XIf set, searches will "wrap around" the ends of the buffer instead
Xof stopping at the bottom or top.  The default is "off".
X.dc "write-files-on-make" "(variable)"
XWhen set, all modified files will be written out before calling
Xmake when the
X.IQ compile-it
Xcommand is executed.  The default is "on".
X.dc "write-word-abbrev-file" "Not Bound"
XThis writes the currently defined abbreviations to a specified file.
XThey can be read back in and automatically defined with
X.IQ read-word-abbrev-file.
X.dc "write-file" "C-X C-W"
XThis saves the current buffer to a specified file, and then makes that
Xfile the default file name for this buffer.  If you specify a file
Xthat already exists you are asked to confirm over-writing it.
X.dc "write-macros-to-file" "Not Bound"
XThis writes the currently defined macros to a specified file.  The
Xmacros can be read back in with
X.IQ read-macros-from-file
Xso you can
Xdefine macros and still use them in other instantiations of \s-2JOVE\s0.
X.dc "write-modified-files" "C-X C-M"
XThis saves all the buffers that need saving.  If you supply a numeric
Xargument it asks for each buffer whether you really want to save it.
X.dc "write-region" "Not Bound"
XThis writes the text in the region to a specified file.  If the file
Xalready exists you are asked to confirm over-writing it.
X.dc "yank" "C-Y"
XThis undoes the last kill command.  That is, it inserts the killed
Xtext at point.  When you do multiple kill commands in a row, they are
Xmerged so that yanking them back with "C\-Y" yanks back all of them.
X.dc "yank-pop" "ESC Y"
XThis yanks back previous killed text.  \s-2JOVE\s0 has a kill ring on which
Xthe last 10 kills are stored.
X.IQ yank
Xyanks a copy of the text at the
Xfront of the ring.  If you want one of the last ten kills you use "ESC
XY" which rotates the ring so another different entry is now at the
Xfront.  You can use "ESC Y" only immediately following a "C-Y" or
Xanother "ESC Y".  If you supply a negative numeric argument the ring
Xis rotated the other way.  If you use this command enough times in a
Xrow you will eventually get back to where you started.  Experiment
Xwith this.  It's extremely useful.
@//E*O*F doc/jove.5//
if test 35706 -ne "`wc -c <'doc/jove.5'`"; then
    echo shar: error transmitting "'doc/jove.5'" '(should have been 35706 characters)'
fi
fi # end of overwriting check
echo shar: "End of archive 12 (of 13)."
cp /dev/null ark12isdone
DONE=true
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13; do
    if test -f ark${I}isdone; then
        echo "You have run archive ${I}."
    else
        echo "You still need to run archive ${I}."
        DONE=false
    fi
done
case $DONE in
    true)
        echo "You have run all 13 archives."
        echo 'Now read the README and Makefile.'
        ;;
esac
##  End of shell archive.
exit 0