v08i028: The JOVE text editor, Part09/13

[sources-request at mirror.UUCP]

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

#! /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 9 (of 13)."
# Contents:  doc/jove.1 doc/jove.nr
PATH=/bin:/usr/bin:/usr/ucb; export PATH
echo shar: extracting "'doc/jove.1'" '(41172 characters)'
if test -f 'doc/jove.1' ; then 
  echo shar: will not over-write existing file "'doc/jove.1'"
else
sed 's/^X//' >doc/jove.1 <<'@//E*O*F doc/jove.1//'
X.\" ditroff -ms
X.de IQ
X\\fI\\$1\\fP
X..
X.de dc
X.NH 2
X\\$1
X.if '\\$2'(variable)' (variable)
X.if !'\\$2'(variable)' (\\$2)
X.LP
X..
X.nr LL 6.5i
X.nr LT 6.5i
X.EH 'USD:17-%''JOVE Manual for UNIX Users'
X.OH 'JOVE Manual for UNIX Users''USD:17-%'
X.LP
X.TL
XJOVE Manual for UNIX Users
X.AU
XJonathan Payne
X(revised for 4.3BSD by Doug Kingston and Mark Seiden)
X.AI
X.AB no
X.AE
X.NH 1
XIntroduction
X.XS \n(PN
X\*(SN Introduction
X.XE
X.LP
X\s-2JOVE\s0*
X.FS
X*\s-2JOVE\s0 stands for Jonathan's Own Version of Emacs.
X.FE
Xis an advanced, self-documenting, customizable real-time display editor.
XIt (and this tutorial introduction) are based on the original EMACS
Xeditor and user manual written at M.I.T. by Richard Stallman+.
X.FS
X+Although \s-2JOVE\s0 is meant to be compatible with EMACS,
Xand indeed many of the basic commands are very similar,
Xthere are some major differences between the two editors,
Xand you should not rely on their behaving identically.
X.FE
X.LP
X\s-2JOVE\s0 is considered a
X.I display 
Xeditor because normally the text being
Xedited is visible on the screen and is updated automatically as you
Xtype your commands.
X.LP
XIt's considered a
X.I real-time 
Xeditor because the display is updated very
Xfrequently, usually after each character or pair of characters you type.
XThis minimizes the amount of information you must keep in your
Xhead as you edit.
X.LP
X\s-2JOVE\s0 is 
X.I advanced 
Xbecause it provides facilities that go beyond
Xsimple insertion and deletion:
Xfilling of text;
Xautomatic indentations of programs;
Xview more than one file at once;
Xand dealing in terms of characters, words, lines, sentences and paragraphs.
XIt is much easier
Xto type one command meaning "go to the end of the paragraph" than to
Xfind the desired spot with repetition of simpler commands.
X.LP
X.I Self-documenting 
Xmeans that at almost any time you can easily
Xfind out what a command does,
Xor to find all the commands that pertain to a topic.
X.LP
X.I Customizable
Xmeans that you can change the definition of \s-2JOVE\s0 commands
Xin little ways.
XFor example, you can rearrange the command set;
Xif you prefer to use arrow keys for the four basic cursor motion commands
X(up, down, left and right), you can.
XAnother sort of customization is
Xwriting new commands by combining built in commands.
X.NH 1
XThe Organization of the Screen
X.XS \n(PN
X\*(SN The Organization of the Screen
X.XE
X.LP
X\s-2JOVE\s0 divides the screen up into several sections.
XThe biggest of these sections is used to display the text you are editing.
XThe terminal's cursor shows the position of \fIpoint\fP,
Xthe location at which editing takes place.
XWhile the cursor appears to point \fIat\fP a character,
Xpoint should be thought of as between characters;
Xit points \fIbefore\fP the character that the cursor appears on top of.
XTerminals have only one cursor,
Xand when output is in progress it must appear where the typing is being done.
XThis doesn't mean that point is moving;
Xit is only that \s-2JOVE\s0 has no way of
Xshowing you the location of point except when the terminal is idle.
X.LP
XThe lines of the screen are usually available for displaying text but
Xsometimes are pre-empted by typeout from certain commands (such as a
Xlisting of all the editor commands).
XMost of the time,
Xoutput from commands like these is only desired for a short period of time,
Xusually just long enough to glance at it.
XWhen you have finished looking at the output,
Xyou can type Space to make your text reappear.
X(Usually a Space that you type inserts itself, but when there is typeout on
Xthe screen, it does nothing but get rid of that).
XAny other command executes normally,
X.I after
Xredrawing your text.
X.NH 2
XThe Message Line
X.XS \n(PN 5n
X\*(SN The Message Line
X.XE
X.LP
XThe bottom line on the screen, called the
X\fImessage line\fP,
Xis reserved for printing messages and for accepting input from the user,
Xsuch as filenames or search strings.
XWhen
X\s-2JOVE\s0 
Xprompts for input,
Xthe cursor will temporarily appear on the bottom line, waiting for you
Xto type a string.
XWhen you have finished typing your input, you can
Xtype a Return to send it to \s-2JOVE\s0.
XIf you change your mind about running the command that is waiting for input,
Xyou can type Control-G to abort,
Xand you can continue with your editing.
X.LP
XWhen \s-2JOVE\s0 is prompting for a filename,
Xall the usual editing facilities can be used to fix typos and such;
Xin addition, \s-2JOVE\s0 has the following extra functions:
X.IP "^N"
XInsert the next filename from the argument list.
X.IP "^P"
XInsert the previous filename from the argument list.
X.IP "^R"
XInsert the full pathname of the file in the current buffer.
X.LP
XSometimes you will see \fB--more--\fP on the message line.
XThis happens when typeout from a command is too long to fit in the screen.
XIt means that if you type a Space the next screenful of typeout will be
Xprinted.
XIf you are not interested,
Xtyping anything but a Space will cause the rest of the output to be discarded.
XTyping C-G will discard the output and print \fIAborted\fP where the \fB--more--\fP was.
XTyping any other command will discard the rest of the output and
Xalso execute the command.
X.LP
XThe message line and the list of filenames from the shell command that
Xinvoked \s-2JOVE\s0 are kept in a special buffer called
X\fIMinibuf\fP that can be edited like any other buffer.
X.NH 2
XThe Mode Line
X.XS \n(PN 5n
X\*(SN The Mode Line
X.XE
X.LP
XAt the bottom of the screen, but above the message line, is the
X\fImode line\fP.  The mode line format looks like this:
X.DS I
X\fBJOVE (major minor)   Buffer: bufr  "file" *\fP
X.DE
X\fImajor\fP is the name of the current \fImajor mode\fP.
XAt any time, \s-2JOVE\s0 can be in only one major mode at a time.
XCurrently there are only four major modes: \fIFundamental\fP,
X\fIText\fP, \fILisp\fP and \fIC\fP.
X.LP
X\fIminor\fP is a list of the minor modes that are turned on.
X\fBAbbrev\fP means that \fIWord Abbrev\fP mode is on;
X\fBAI\fP means that \fIAuto Indent\fP mode is on;
X\fBFill\fP means that \fIAuto Fill\fP mode is on;
X\fBOvrWt\fP means that \fIOver Write\fP mode is on.
X\fBDef\fP means that you are in the process of defining a keyboard macro.
XThis is not really a mode,
Xbut it's useful to be reminded about it.
XThe meanings of these modes are described later in this document.
X.LP
X\fIbufr\fP is the name of the currently selected \fIbuffer\fP.
XEach buffer has its own name and holds a file being edited;
Xthis is how \s-2JOVE\s0 can hold several files at once.
XBut at any given time you are editing only one of them,
Xthe \fIselected\fP buffer.
XWhen we speak of what some command does to "the buffer",
Xwe are talking about the currently selected buffer.
XMultiple buffers makes it easy to switch around between several files,
Xand then it is very useful that
Xthe mode line tells you which one you are editing at any time.  (You
Xwill see later that it is possible to divide the
Xscreen into multiple \fIwindows\fP, each showing a different buffer.  If you
Xdo this, there is a mode line beneath each window.)
X.LP
X\fIfile\fP is the name of the file that you are editing.
XThis is the default filename for commands that expect a filename as input.
X.LP
XThe asterisk at the end of the mode line means that there are changes in
Xthe buffer that have not been saved in the file.
XIf the file has not been changed since it was read in or saved,
Xthere is no asterisk.
X.NH 1
XCommand Input Conventions
X.XS \n(PN
X\*(SN Command Input Conventions
X.XE
X.LP
X.NH 2
XNotational Conventions for ASCII Characters
X.XS \n(PN 5n
X\*(SN Notational Conventions for ASCII Characters
X.XE
X.LP
XIn this manual,
X"Control" characters
X(that is, characters that are typed with the Control key
Xand some other key at the same time)
Xare represented by "C-" followed by another character.
XThus,
XC-A is the character you get when you type A with the Control key
X(sometimes labeled CTRL) down.
XMost control characters when present in the \s-2JOVE\s0
Xbuffer are displayed with a caret; thus, ^A for C-A.
XRubout (or DEL) is displayed as ^?, escape as ^[.
X.NH 2
XCommand and Filename Completion
X.XS \n(PN 5n
X\*(SN Command and Filename Completion
X.XE
X.LP
XWhen you are typing the name of a \s-2JOVE\s0 command, you need type only
Xenough letters to make the name unambiguous.  At any point in the course of
Xtyping the name, you can type question mark (?) to see a list of all the
Xcommands whose names begin with the characters you've already typed; you can
Xtype Space to have \s-2JOVE\s0 supply as many characters as it can; or you
Xcan type Return to complete the command if there is only one possibility.
XFor example, if you have typed the letters "\fIau\fP" and you then type a
Xquestion mark, you will see the list
X.DS I
X   auto-execute-command
X   auto-execute-macro
X   auto-fill-mode
X   auto-indent-mode
X.DE
XIf you type a Return at this point, \s-2JOVE\s0 will complain by ringing
Xthe bell, because the letters you've typed do not unambiguously specify a
Xsingle command.  But if you type Space, \s-2JOVE\s0 will supply the
Xcharacters "\fIto-\fP" because all commands that begin "\fIau\fP" also
Xbegin "\fIauto-\fP".  You could then type the letter "\fIf\fP" followed
Xby either Space or Return, and \s-2JOVE\s0 would complete the entire
Xcommand.
X.LP
XWhenever \s-2JOVE\s0 is prompting you for a filename, say in the
X\fIfind-file\fP command, you also need only type enough of the name to
Xmake it unambiguous with respect to files that already exist.  In this
Xcase, question mark and Space work just as they do in command completion,
Xbut Return always accepts the name just as you've typed it, because you
Xmight want to create a new file with a name similar to that of an
Xexisting file.  The variable \fIbad-filename-extensions\fP contains a
Xlist of words separated by spaces which are to be considered bad
Xfilename extensions, and so will not be counted in filename completion.
XThe default is ".o" so if you have jove.c and jove.o in the same
Xdirectory, the filename completion will not complain of an ambiguity
Xbecause it will ignore jove.o.
X
X.NH 1
XCommands and Variables
X.XS \n(PN
X\*(SN Commands and Variables
X.XE
X.LP
X\s-2JOVE\s0 is composed of \fIcommands\fP
Xwhich have long names such as
X\fInext-line\fP.
XThen \fIkeys\fP such as C-N are connected to
Xcommands through the \fIcommand dispatch table\fP.
XWhen we say that C-N moves the cursor down a line,
Xwe are glossing over a distinction which is unimportant for ordinary use,
Xbut essential for simple customization:
Xit is the command \fInext-line\fP which knows how to move a down line,
Xand C-N moves down a line because it is connected to that command.
XThe name for this connection is a \fIbinding\fP; we say that the key
XC-N \fIis bound to\fP the command \fInext-line\fP.
X.LP
XNot all commands are bound to keys.  To invoke a command that isn't bound
Xto a key, you can type the sequence ESC X, which is bound to the command
X\fIexecute-named-command\fP.  You will then be able to type the name of
Xwhatever command you want to execute on the message line.
X.LP
XSometimes the description of a command will say
X"to change this, set the variable \fImumble\-foo\fP".
XA variable is a name used to remember a value.
X\s-2JOVE\s0 contains variables which are there so that you can change
Xthem if you want to customize.
XThe variable's value is examined by some command,
Xand changing that value makes the command behave differently.
XUntil you are interesting in customizing \s-2JOVE\s0,
Xyou can ignore this information.
X.NH 2
XPrefix Characters
X.XS \n(PN 5n
X\*(SN Prefix Characters
X.XE
X.LP
XBecause there are more command names than keys,
X\s-2JOVE\s0 provides
X\fIprefix characters\fP to increase the number of commands that can
Xbe invoked quickly and easily.
XWhen you type a prefix character \s-2JOVE\s0 will wait
Xfor another character before deciding what to do.
XIf you wait more than a second or so,
X\s-2JOVE\s0 will print the prefix character on the
Xmessage line as a reminder and leave the cursor down there until you type your next
Xcharacter.
XThere are two prefix characters built into \s-2JOVE\s0:
XEscape and Control-X.
XHow the next character is interpreted depends on which
Xprefix character you typed.
XFor example,
Xif you type Escape followed by B you'll run \fIbackward-word\fP,
Xbut if you type Control-X followed by B you'll run \fIselect-buffer\fP.
XElsewhere in this manual, the Escape key is indicated as "ESC", which is
Xalso what \s-2JOVE\s0 displays on the message line for Escape.
X.NH 2
XHelp
X.XS \n(PN
X\*(SN Help
X.XE
X.LP
XTo get a list of keys and their associated commands,
Xyou type ESC X \fIdescribe-bindings\fP.
XIf you want to describe a single key,
XESC X \fIdescribe-key\fP will work.  A description of an
Xindividual command is available by using ESC X \fIdescribe-command\fP,
Xand descriptions of variables by using  ESC X \fIdescribe-variable\fP.
XIf you can't remember the name of the thing you want to know about,
XESC X \fIapropos\fP will tell you if a command or variable has a given
Xstring in its name.  For example, ESC X \fIapropos describe\fP will
Xlist the names of the four describe commands mentioned briefly in this
Xsection.
X.NH 1
XBasic Editing Commands
X.XS \n(PN
X\*(SN Basic Editing Commands
X.XE
X.LP
X.NH 2
XInserting Text
X.XS \n(PN 5n
X\*(SN Inserting Text
X.XE
X.LP
XTo insert printing characters into the text you are editing,
Xjust type them.
XAll printing characters you type are inserted into the text at
Xthe cursor (that is, at \fIpoint\fP),
Xand the cursor moves forward.
XAny characters after the cursor move forward too.
XIf the text in the buffer is FOOBAR,
Xwith the cursor before the B,
Xthen if you type XX,
Xyou get FOOXXBAR,
Xwith the cursor still before the B.
X.LP
XTo correct text you have just inserted,
Xyou can use Rubout.
XRubout deletes the character \fIbefore\fP the cursor (not the one that the
Xcursor is on top of or under; that is the character \fIafter\fP the
Xcursor).
XThe cursor and all characters after it move backwards.
XTherefore,
Xif you typing a printing character and then type Rubout,
Xthey cancel out.
X.LP
XTo end a line and start typing a new one,
Xtype Return.
XReturn operates by inserting a \fIline-separator\fP,
Xso if you type Return in
Xthe middle of a line,
Xyou break the line in two.
XBecause a line-separator is just a single character,
Xyou can type Rubout at the
Xbeginning of a line to delete the line-separator and join it with the
Xpreceding line.
X.LP
XAs a special case, if you type Return at the end of a line and there are
Xtwo or more empty lines just below it, \s-2JOVE\s0 does not insert a
Xline-separator but instead merely moves to the next (empty) line.  This
Xbehavior is convenient when you want to add several lines of text in the
Xmiddle of a buffer.  You can use the Control-O (\fInewline-and-backup\fP)
Xcommand to "open" several empty lines at once; then you can insert the new
Xtext, filling up these empty lines.  The advantage is that \s-2JOVE\s0 does
Xnot have to redraw the bottom part of the screen for each Return you type,
Xas it would ordinarily.  That "redisplay" can be both slow and distracting.
X.LP
XIf you add too many characters to one line,
Xwithout breaking it with Return,
Xthe line will grow too long to display on one screen line.
XWhen this happens,
X\s-2JOVE\s0 puts an "!" at the extreme right margin,
Xand doesn't bother to display the rest of the line unless the
Xcursor happens to be in it.
XThe "!" is not part of your text;
Xconversely,
Xeven though you can't see the rest of your line,
Xit's still there,
Xand if you break the line,
Xthe "!" will go away.
X.LP
XDirect insertion works for printing characters and space,
Xbut other
Xcharacters act as editing commands and do not insert themselves.
XIf you need to insert a control character,
XEscape,
Xor Rubout,
Xyou must first \fIquote\fP it by typing the Control-Q command first.
X.NH 2
XMoving the Cursor
X.XS \n(PN 5n
X\*(SN Moving the Cursor
X.XE
X.LP
XTo do more than insert characters,
Xyou have to know how to move the cursor.
XHere are a few of the commands for doing that.
X.IP "C-A" 15n
XMove to the beginning of the line.
X.IP "C-E" 15n
XMove to the end of the line.
X.IP "C-F" 15n
XMove forward over one character.
X.IP "C-B" 15n
XMove backward over one character.
X.IP "C-N" 15n
XMove down one line,
Xvertically.
XIf you start in the middle of one line,
Xyou end in the middle of the next.
X.IP "C-P" 15n
XMove up one line,
Xvertically.
X.IP "ESC <" 15n
XMove to the beginning of the entire buffer.
X.IP "ESC >" 15n
XMove to the end of the entire buffer.
X.IP "ESC ," 15n
XMove to the beginning of the visible window.
X.IP "ESC ." 15n
XMove to the end of the visible window.
X.NH 2
XErasing Text
X.XS \n(PN 5n
X\*(SN Erasing Text
X.XE
X.LP
X.IP "Rubout" 15n
XDelete the character before the cursor.
X.IP "C-D" 15n
XDelete the character after the cursor.
X.IP "C-K" 15n
XKill to the end of the line.
X.LP
XYou already know about the Rubout command which deletes the character
Xbefore the cursor.
XAnother command,
XControl-D,
Xdeletes the character
Xafter the cursor,
Xcausing the rest of the text on the line to shift left.
XIf Control-D is typed at the end of a line,
Xthat line and the next line are joined together.
X.LP
XTo erase a larger amount of text,
Xuse the Control-K command,
Xwhich kills a line at a time.
XIf Control-K is done at the beginning or
Xmiddle of a line,
Xit kills all the text up to the end of the line.
XIf Control-K is done at the end of a line,
Xit joins that line and the next line.
XIf Control-K is done twice, it kills the rest of the line and the line
Xseparator also.
X.NH 2
XFiles \(em Saving Your Work
X.XS \n(PN 5n
X\*(SN Files \(em Saving Your Work
X.XE
X.LP
XThe commands above are sufficient for creating text in the \s-2JOVE\s0 buffer.
XThe more advanced \s-2JOVE\s0 commands just make things easier.
XBut to keep any text permanently you must put it in a \fIfile\fP.
XFiles are the objects which
X.UX
Xuses for storing data for a length of time.
XTo tell \s-2JOVE\s0 to read text into a file,
Xchoose a filename,
Xsuch as \fIfoo.bar\fP,
Xand type C-X C-R \fIfoo.bar\fP<return>.
XThis reads the file \fIfoo.bar\fP so that its contents appear on the screen
Xfor editing.
XYou can make changes,
Xand then save the file by typing C-X C-S (save-file).
XThis makes the changes permanent and actually changes the file \fIfoo.bar\fP.
XUntil then,
Xthe changes are only inside \s-2JOVE\s0,
Xand the file \fIfoo.bar\fP is not really changed.
XIf the file \fIfoo.bar\fP doesn't exist,
Xand you want to create it,
Xread it as if it did exist.
XWhen you save your text with C-X C-S the file will be created.
X.NH 2
XExiting and Pausing \(em Leaving \s-2JOVE\s0
X.XS \n(PN 5n
X\*(SN Exiting and Pausing \(em Leaving \s-2JOVE\s0
X.XE
X.LP
XThe command C-X C-C (\fIexit-jove\fP) will terminate the \s-2JOVE\s0
Xsession and return to the shell.  If there are modified but 
Xunsaved buffers, \s-2JOVE\s0 will ask you for confirmation, and you
Xcan abort the command, look at what buffers are
Xmodified but unsaved using C-X C-B (\fIlist-buffers\fP), save the 
Xvaluable ones, and then exit.  If what you want to do, on the other hand,
Xis \fIpreserve\fP the editing session but return to the shell temporarily
Xyou can (under Berkeley 
X.UX
Xonly) issue the command ESC S (\fIpause-jove\fP), do your 
X.UX 
Xwork within the c-shell, then return to \s-2JOVE\s0 using the 
X\fIfg\fP command to resume editing at the point where you paused.
XFor this sort of situation you might consider using an \fIinteractive
Xshell\fP (that is, a shell in a \s-2JOVE\s0 window) which lets you use
Xeditor commands to manipulate your 
X.UX 
Xcommands (and their output) while never leaving the editor.
X(The interactive shell feature is described below.)
X.NH 2
XGiving Numeric Arguments to \s-2JOVE\s0 Commands
X.XS \n(PN 5n
X\*(SN Giving Numeric Arguments to \s-2JOVE\s0 Commands
X.XE
X.LP
XAny \s-2JOVE\s0 command can be given a \fInumeric argument\fP.
XSome commands interpret the argument as a repetition count.
XFor example,
Xgiving an argument of ten to the C-F command (forward-character) moves forward
Xten characters.
XWith these commands,
Xno argument is equivalent to an argument of 1.
X.LP
XSome commands use the value of the argument,
Xbut do something peculiar (or nothing) when there is no argument.
XFor example,
XESC G (\fIgoto-line\fP) with an argument \fBn\fP
Xgoes to the beginning of the \fBn\fP'th line.
XBut ESC G with no argument doesn't do anything.
XSimilarly, C-K with an argument kills that many lines, including their line
Xseparators.  Without an argument, C-K when there is text on the line to the
Xright of
Xthe cursor kills that text; when there is no text after the cursor, C-K
Xdeletes the line separator.
X.LP
XThe fundamental way of specifying an argument is to use ESC followed
Xby the digits of the argument, for example, ESC 123 ESC G to go to line
X123. Negative arguments are allowed,
Xalthough not all of the commands know what to do with one.
X.LP
XTyping C-U means do the next command four times.
XTwo such C-U's multiply the next command by sixteen.
XThus,
XC-U C-U C-F moves forward sixteen characters.
XThis is a good way to move forward quickly,
Xsince it moves about 1/4 of a line on most terminals.
XOther useful combinations are:
XC-U C-U C-N (move down a good fraction of the screen),
XC-U C-U C-O (make "a lot" of blank lines),
Xand C-U C-K (kill four lines \(em note that typing C-K four times
Xwould kill 2 lines).
X.LP
XThere are other,
Xterminal-dependent ways of specifying arguments.
XThey have the same effect but may be easier to type.
XIf your terminal
Xhas a numeric keypad which sends something recognizably different from
Xthe ordinary digits,
Xit is possible to program \s-2JOVE\s0 to to allow use of
Xthe numeric keypad for specifying arguments.
X.NH 2
XThe Mark and the Region
X.XS \n(PN 5n
X\*(SN The Mark and the Region
X.XE
X.LP
XIn general,
Xa command that processes an arbitrary part of the buffer
Xmust know where to start and where to stop.
XIn \s-2JOVE\s0,
Xsuch commands usually operate on the text between point and \fIthe mark\fP.
XThis body of text is called \fIthe region\fP.
XTo specify a region,
Xyou set point to one end of it and mark at the other.
XIt doesn't matter which one comes earlier in the text.
X.IP "C-@" 15n
XSet the mark where point is.
X.IP "C-X C-X" 15n
XInterchange mark and point.
X.LP
XFor example,
Xif you wish to convert part of the buffer to all upper-case,
Xyou can use the C-X C-U command,
Xwhich operates on the text in the region.
XYou can first go to the beginning of the text to be capitalized,
Xput the mark there, move to the end, and then type C-X C-U.
XOr,
Xyou can set the mark at the end of the text,
Xmove to the beginning,
Xand then type C-X C-U.
XC-X C-U runs the command \fIcase-region-upper\fP,
Xwhose name signifies that the region,
Xor everything between point and mark,
Xis to be capitalized.
X.LP
XThe way to set the mark is with the C-@ command or (on some
Xterminals) the C-Space command.
XThey set the mark where point is.
XThen you can move point away,
Xleaving mark behind.  When the mark is set, "[Point pushed]" is printed on
Xthe message line.
X.LP
XSince terminals have only one cursor,
Xthere is no way for \s-2JOVE\s0 to show you where the mark is located.
XYou have to remember.
XThe usual solution to this problem is to set the mark and then use it soon,
Xbefore you forget where it is.
XBut you can see where the mark is with
Xthe command C-X C-X which puts the mark where point was and point
Xwhere mark was.
XThe extent of the region is unchanged,
Xbut the cursor and point are now at the previous location of the mark.
X.NH 2
XThe Ring of Marks
X.XS \n(PN 5n
X\*(SN The Ring of Marks
X.XE
X.LP
XAside from delimiting the region,
Xthe mark is also useful for remembering a spot that you may want to go back to.
XTo make this feature more useful,
X\s-2JOVE\s0 remembers 16 previous locations of the mark.
XMost commands that set the mark push the old mark onto this stack.
XTo return to a marked location, use C-U C- at .
XThis moves point to where the mark was,
Xand restores the mark from the stack of former marks.
XSo repeated use of this command moves point to all of the old
Xmarks on the stack,
Xone by one.
XSince the stack is actually a ring,
Xenough uses of C-U C-@ bring point back to where it was originally.
X.LP
XSome commands whose primary purpose is to move point a great distance
Xtake advantage of the stack of marks to give you a way to undo the
Xcommand.
XThe best example is ESC <,
Xwhich moves to the beginning of the buffer.
XIf there are more than 22 lines between the beginning of
Xthe buffer and point,
XESC < sets the mark first,
Xso that you can use C-U C-@ or C-X C-X to go back to where you were.
XYou can change the number of lines from 22 since it is kept in the variable \fImark-threshold\fP.
XBy setting it to 0,
Xyou can make these commands always set the mark.
XBy setting it to a very large number you can prevent these commands from ever
Xsetting the mark.
XIf a command decides to set the mark,
Xit prints the message \fI[Point pushed]\fP.
X.NH 2
XKilling and Moving Text
X.XS \n(PN 5n
X\*(SN Killing and Moving Text
X.XE
X.LP
XThe most common way of moving or copying text with \s-2JOVE\s0 is to kill it,
Xand get it back again in one or more places.
XThis is very safe
Xbecause the last several pieces of killed text are all remembered,
Xand it is versatile,
Xbecause the many commands for killing syntactic units
Xcan also be used for moving those units.
XThere are also other ways of moving text for special purposes.
X.NH 2
XDeletion and Killing
X.XS \n(PN 5n
X\*(SN Deletion and Killing
X.XE
X.LP
XMost commands which erase text from the buffer save it so that you can
Xget it back if you change your mind,
Xor move or copy it to other parts of the buffer.
XThese commands are known as \fIkill\fP commands.
XThe rest of the commands that erase text do not save it;
Xthey are known as \fIdelete\fP commands.
XThe delete commands include C-D and Rubout,
Xwhich delete only one character at a time,
Xand those commands that delete only spaces or line separators.
XCommands that can destroy significant amounts of nontrivial data generally kill.
XA command's
Xname and description will use the words \fIkill\fP or \fIdelete\fP to
Xsay which one it does.
X.IP "C-D" 20n
XDelete next character.
X.IP "Rubout" 20n
XDelete previous character.
X.IP "ESC \\\\\\\\" 20n
XDelete spaces and tabs around point.
X.IP "C-X C-O" 20n
XDelete blank lines around the current line.
X.IP "C-K" 20n
XKill rest of line or one or more lines.
X.IP "C-W" 20n
XKill region (from point to the mark).
X.IP "ESC D" 20n
XKill word.
X.IP "ESC Rubout" 20n
XKill word backwards.
X.IP "ESC K" 20n
XKill to end of sentence.
X.IP "C-X Rubout" 20n
XKill to beginning of sentence.
X.NH 2
XDeletion
X.XS \n(PN 5n
X\*(SN Deletion
X.XE
X.LP
XThe most basic delete commands are C-D and Rubout.
XC-D deletes the character after the cursor,
Xthe one the cursor is "on top of" or "underneath".
XThe cursor doesn't move.
XRubout deletes the character before the cursor,
Xand moves the cursor back.
XLine separators act like normal characters when deleted.
XActually,
XC-D and Rubout aren't always \fIdelete\fP commands;
Xif you give an argument,
Xthey \fIkill\fP instead.
XThis prevents you from losing a great deal of text by typing a large
Xargument to a C-D or Rubout.
X.LP
XThe other delete commands are those which delete only formatting
Xcharacters:
Xspaces,
Xtabs,
Xand line separators.
XESC \\ (\fIdelete-white-space\fP)
Xdeletes all the spaces and tab characters before and after point.
XC-X C-O (\fIdelete-blank-lines\fP) deletes all blank lines after the current line,
Xand if the current line is blank deletes all the blank
Xlines preceding the current line as well
X(leaving one blank line, the current line).
X.NH 2
XKilling by Lines
X.XS \n(PN 5n
X\*(SN Killing by Lines
X.XE
X.LP
XThe simplest kill command is the C-K command.
XIf issued at the beginning of a line,
Xit kills all the text on the line,
Xleaving it blank.
XIf given on a line containing only white space (blanks and tabs)
Xthe line disappears.
XAs a consequence,
Xif you go to the front of a non-blank line and type two C-K's,
Xthe line disappears completely.
X.LP
XMore generally,
XC-K kills from point up to the end of the line,
Xunless it is at the end of a line.
XIn that case,
Xit kills the line separator following the line,
Xthus merging the next line into the current one.
XInvisible spaces and tabs at the end of the line are ignored when
Xdeciding which case applies,
Xso if point appears to be at the end of the line,
Xyou can be sure the line separator will be killed.
X.LP
XC-K with an argument of zero kills all the text before
Xpoint on the current line.
X.NH 2
XOther Kill Commands
X.XS \n(PN 5n
X\*(SN Other Kill Commands
X.XE
X.LP
XA kill command which is very general is C-W (\fIkill-region\fP),
Xwhich kills everything between point and the mark.*
X.FS
X*Often users switch this binding from C-W to C-X C-K because it is too
Xeasy to hit C-W accidentally.
X.FE
XWith this command,
Xyou can kill and save contiguous characters,
Xif you first set the mark at one end of them and go to the other end.
X.LP
XOther syntactic units can be killed, too;
Xwords,
Xwith ESC Rubout and ESC D;
Xand, sentences,
Xwith ESC K and C-X Rubout.
X.NH 2
XUn-killing
X.XS \n(PN 5n
X\*(SN Un-killing (Yanking)
X.XE
X.LP
XUn-killing (yanking) is getting back text which was killed.
XThe usual way to
Xmove or copy text is to kill it and then un-kill it one or more times.
X.IP "C-Y" 10n
XYank (re-insert) last killed text.
X.IP "ESC Y" 10n
XReplace re-inserted killed text with the previously killed text.
X.IP "ESC W" 10n
XSave region as last killed text without killing.
X.LP
XKilled text is pushed onto a \fIring buffer\fP called the \fIkill
Xring\fP that remembers the last 10 blocks of text that were killed.
X(Why it is called a ring buffer will be explained below).
XThe command C-Y (\fIyank\fP) reinserts the text of the most recent kill.
XIt leaves the cursor at the end of the text,
Xand puts the mark at the beginning.
XThus,
Xa single C-Y undoes the C-W.
X.LP
XIf you wish to copy a block of text,
Xyou might want to use ESC W (\fIcopy-region\fP),
Xwhich copies the region into the kill ring without removing it from the buffer.
XThis is approximately equivalent to C-W followed by C-Y,
Xexcept that ESC W does not mark the buffer as
X"changed" and does not cause the screen to be rewritten.
X.LP
XThere is only one kill ring shared among all the buffers.
XAfter visiting a new file,
Xwhatever was last killed in the previous file is still on top of the kill ring.
XThis is important for moving text between files.
X.NH 2
XAppending Kills
X.XS \n(PN 5n
X\*(SN Appending Kills
X.XE
X.LP
XNormally,
Xeach kill command pushes a new block onto the kill ring.
XHowever,
Xtwo or more kill commands immediately in a row (without any other
Xintervening commands) combine their text into a
Xsingle entry on the ring,
Xso that a single C-Y command gets it all back as it was before it was killed.
XThis means that you don't have to kill all the text in one command;
Xyou can keep killing line after line,
Xor word after word,
Xuntil you have killed it all,
Xand you can still get it all back at once.
X.LP
XCommands that kill forward from 
X.I point 
Xadd onto the end of the previous
Xkilled text.
XCommands that kill backward from 
X.I point
Xadd onto the beginning.
XThis way,
Xany sequence of mixed forward and backward kill
Xcommands puts all the killed text into one entry without needing rearrangement.
X.NH 2
XUn-killing Earlier Kills
X.XS \n(PN 5n
X\*(SN Un-killing Earlier Kills
X.XE
X.LP
XTo recover killed text that is no longer the most recent kill,
Xyou need the ESC Y (\fIyank-pop\fP) command.
XThe ESC Y command can be used
Xonly after a C-Y (yank) command or another ESC Y.
XIt takes the un-killed
Xtext inserted by the C-Y and replaces it with the text from an earlier
Xkill.
XSo,
Xto recover the text of the next-to-the-last kill,
Xyou first use C-Y to recover the last kill,
Xand then discard it by use of ESC Y to move back to the previous kill.
X.LP
XYou can think of all the last few kills as living on a ring.
XAfter a C-Y command,
Xthe text at the front of the ring is also present in the buffer.
XESC Y "rotates" the ring bringing the previous string of text to the front
Xand this text replaces the other text in the buffer as well.
XEnough ESC Y commands can rotate any part of the ring to the front,
Xso you can get at any killed text so long as it is recent enough
Xto be still in the ring.
XEventually the ring rotates all the way
Xaround and the most recently killed text comes to the front
X(and into the buffer) again.
XESC Y with a negative argument rotates the ring backwards.
X.LP
XWhen the text you are looking for is brought into the buffer,
Xyou can stop doing ESC Y's and the text will stay there.
XIt's really just a copy of what's at the front of the ring,
Xso editing it does not change what's in the ring.
XAnd the ring,
Xonce rotated,
Xstays rotated,
Xso that doing another C-Y gets another copy of what you rotated to the
Xfront with ESC Y.
X.LP
XIf you change your
Xmind about un-killing,
XC-W gets rid of the un-killed text, even
Xafter any number of ESC Y's.
X.NH 1
XSearching
X.XS \n(PN
X\*(SN Searching
X.XE
X.LP
XThe search commands are useful for finding and moving to arbitrary
Xpositions in the buffer in one swift motion.
XFor example,
Xif you just ran the spell program on a paper
Xand you want to correct some word,
Xyou can use the search commands to move directly to that word.  There are
Xtwo flavors of search: \fIstring search\fP and \fIincremental search\fP.
XThe former is the default flavor\(emif you want to use incremental search
Xyou must rearrange the key bindings (see below).
X.NH 2
XConventional Search
X.XS \n(PN 5n
X\*(SN Conventional Search
X.XE
X.LP
X.IP "C-S" 15n
XSearch forward.
X.IP "C-R" 15n
XSearch backward.
X.LP
XTo search for the string "FOO" you type "C-S FOO<return>".
XIf \s-2JOVE\s0 finds
XFOO it moves point to the end of it; otherwise \s-2JOVE\s0 prints an error
Xmessage and leaves point unchanged.
XC-S searches forward from point
Xso only occurrences of FOO after point are found.
XTo search in the other direction use C-R.
XIt is exactly the same as C-S except it searches in the opposite direction,
Xand if it finds the string,
Xit leaves point at the beginning of it,
Xnot at the end as in C-S.
X.LP
XWhile \s-2JOVE\s0 is searching it prints the search string on the message line.
XThis is so you know what \s-2JOVE\s0 is doing.
XWhen the system is heavily loaded and
Xediting in exceptionally large buffers,
Xsearches can take several (sometimes many) seconds.
X.LP
X\s-2JOVE\s0 remembers the last search string you used,
Xso if you want to search for the same string you can type "C-S <return>".
XIf you mistyped the last search string,
Xyou can type C-S followed by C-R.
XC-R,
Xas usual,
Xinserts the default search string into the minibuffer,
Xand then you can fix it up.
X.NH 2
XIncremental Search
X.XS \n(PN 5n
X\*(SN Incremental Search
X.XE
X.LP
XThis search command is unusual in that is is \fIincremental\fP;
Xit begins to search before you have typed the complete search string.
XAs you type in the search string,
X\s-2JOVE\s0 shows you where it would be found.
XWhen you have typed enough characters to identify the place you want,
Xyou can stop.
XDepending on what you will do next,
Xyou may or may not need to terminate the search explicitly with a Return first.
X.LP
XThe command to search is C-S (\fIi-search-forward\fP).
XC-S reads in characters and positions the cursor at the first
Xoccurrence of the characters that you have typed so far.
XIf you type C-S and then F,
Xthe cursor moves in the text just after the next "F".
XType an "O",
Xand see the cursor move to after the next "FO".
XAfter another "O",
Xthe cursor is after the next "FOO".
XAt the same time,
Xthe "FOO" has echoed on the message line.
X.LP
XIf you type a mistaken character,
Xyou can rub it out.
XAfter the FOO,
Xtyping a Rubout makes the "O" disappear from the message line,
Xleaving only "FO".
XThe cursor moves back in the buffer to the "FO".
XRubbing out the "O" and "F" moves the cursor back to where you
Xstarted the search.
X.LP
XWhen you are satisfied with the place you have reached,
Xyou can type a Return,
Xwhich stops searching,
Xleaving the cursor where the search brought it.
XAlso,
Xany command not specially meaningful in searches stops
Xthe searching and is then executed.
XThus,
Xtyping C-A would exit the search and then move to the beginning of the line.
XReturn is necessary only if the next character you want to type is a printing
Xcharacter,
XRubout,
XReturn,
Xor another search command,
Xsince those are the characters that have special meanings inside the search.
X.LP
XSometimes you search for "FOO" and find it,
Xbut not the one you hoped to find.
XPerhaps there is a second FOO that you forgot about,
Xafter the one you just found.
XThen type another C-S and the cursor will find the next FOO.
XThis can be done any number of times.
XIf you overshoot,
Xyou can return to previous finds by rubbing out the C-S's.
X.LP
XAfter you exit a search,
Xyou can search for the same string again by typing just C-S C-S:
Xone C-S command to start the search and then
Xanother C-S to mean "search again for the same string".
X.LP
XIf your string is not found at all,
Xthe message line says "Failing I-search".
XThe cursor is after the place where \s-2JOVE\s0 found as much of
Xyour string as it could.
XThus,
Xif you search for FOOT and there is no FOOT,
Xyou might see the cursor after the FOO in FOOL.
XAt this point there are several things you can do.
XIf your string was mistyped,
Xyou can rub some of it out and correct it.
XIf you like the place you have found,
Xyou can type Return or some other \s-2JOVE\s0 command
Xto "accept what the search offered".
XOr you can type C-G,
Xwhich undoes the search altogether and positions you back where you started
Xthe search.
X.LP
XYou can also type C-R at any time to start searching backwards.
XIf a search fails because the place you started was too late in the file,
Xyou should do this.
XRepeated C-R's keep looking backward for more occurrences of the last search string.
XA C-S starts going forward again.
XC-R's can be rubbed out just like anything else.
X.NH 2
XSearching with Regular Expressions
X.XS \n(PN 5n
X\*(SN Searching with Regular Expressions
X.XE
X.LP
XIn addition to the searching facilities described above,
X\s-2JOVE\s0
Xcan search for patterns using regular expressions.
XThe handling of regular expressions in \s-2JOVE\s0 is like that of \fIed(1)\fP
Xor \fIvi(1)\fP, but with some notable additions.
XThe extra metacharacters understood by \s-2JOVE\s0 are \e<,
X\e>,
X\e\|| and \e\|{.
XThe first two of these match the beginnings and endings of words;
XThus the search pattern,
X"\|\e<Exec" would match all words beginning with the letters "Exec".
X.LP
XAn \e\|| signals the beginning of an alternative \(em that is, the
Xpattern "foo\e\||bar" would match either "foo" or "bar".  The "curly
Xbrace" is a way of introducing several sub-alternatives into a pattern.
XIt parallels the [] construct of regular expressions, except it specifies
Xa list of alternative words instead of just alternative characters.  So
Xthe pattern "foo\e\|{bar,baz\e\|}bie" matches "foobarbie" or "foobazbie".
X.LP
X\s-2JOVE\s0 only regards metacharacters as special if the variable
X\fImatch-regular-expressions\fP is set to "on".
XThe ability to have \s-2JOVE\s0 ignore these characters is useful if
Xyou're editing a document about patterns and regular expressions or
Xwhen a novice is learning \s-2JOVE\s0.
X.LP
XAnother variable that affects searching is \fIcase-ignore-search\fP.  If
Xthis variable is set to "on" then upper case and lower case letters are
Xconsidered equal.
X.NH 1
XReplacement Commands
X.XS \n(PN
X\*(SN Replacement Commands
X.XE
X.LP
XGlobal search-and-replace operations are not needed as often in \s-2JOVE\s0
Xas they are in other editors,
Xbut they are available.
XIn addition to
Xthe simple Replace operation which is like that found in most editors,
Xthere is a Query Replace operation which asks,
Xfor each occurrence of the pattern,
Xwhether to replace it.
X.NH 2
XGlobal replacement
X.XS \n(PN 5n
X\*(SN Global Replacement
X.XE
X.LP
XTo replace every occurrence of FOO after point with BAR,
Xyou can do, e.g., "ESC R FOO<return>BAR" as the \fIreplace-string\fP command
Xis bound to the ESC R.
XReplacement takes place only between point and the end of the buffer
Xso if you want to cover the whole buffer you must go to the beginning first.
X.NH 2
XQuery Replace
X.XS \n(PN 5n
X\*(SN Query Replace
X.XE
X.LP
XIf you want to change only some of the occurrences of FOO,
Xnot all,
Xthen the global \fIreplace-string\fP is inappropriate;
XInstead,
Xuse, e.g., "ESC Q FOO<return>BAR", to run the command \fIquery-replace-string\fP.
XThis displays each occurrence of FOO and waits for you to say whether
Xto replace it with a BAR.
XThe things you can type when you are shown an occurrence of FOO are:
X.IP "Space" 15n
Xto replace the FOO.
X.IP "Rubout" 15n
Xto skip to the next FOO without replacing this one.
X.IP "Return" 15n
Xto stop without doing any more replacements.
X.IP "Period" 15n
Xto replace this FOO and then stop.
X.IP "! or P" 15n
Xto replace all remaining FOO's without asking.
X.IP "C-R or R" 15n
Xto enter a recursive editing level,
Xin case the FOO needs to be edited rather than just replaced with a BAR.
XWhen you are done,
Xexit the recursive editing level with C-X C-C and the next FOO will
Xbe displayed.
X.IP "C-W" 15n
Xto delete the FOO, and then start editing the buffer.
XWhen you are finished editing whatever is to replace the FOO,
Xexit the recursive editing level with C-X C-C
Xand the next FOO will be displayed.
X.IP "U" 15n
Xmove to the last replacement and undo it.
X.LP
XAnother alternative is using \fIreplace-in-region\fP which is just like
X\fIreplace-string\fP except it searches only within the region.
X.LP
@//E*O*F doc/jove.1//
if test 41172 -ne "`wc -c <'doc/jove.1'`"; then
    echo shar: error transmitting "'doc/jove.1'" '(should have been 41172 characters)'
fi
fi # end of overwriting check
echo shar: extracting "'doc/jove.nr'" '(9034 characters)'
if test -f 'doc/jove.nr' ; then 
  echo shar: will not over-write existing file "'doc/jove.nr'"
else
sed 's/^X//' >doc/jove.nr <<'@//E*O*F doc/jove.nr//'
X.hy 0
X.TH JOVE 1 "12 February 1986"
X.ad
X.SH NAME
Xjove - an interactive display-oriented text editor
X.SH SYNOPSIS
X.nf
Xjove [-d directory] [-w] [-t tag] [+n file] [-p file] [files]
Xjove -r
X.fi
X.SH DESCRIPTION
XJOVE is Jonathan's Own Version of Emacs.  It is based on the original EMACS
Xeditor written at MIT by Richard Stallman.  Although JOVE is meant to be
Xcompatible with EMACS, there are some major differences between the two
Xeditors and you shouldn't rely on their behaving identically.
X.LP
XJOVE works on any reasonable display terminal that is described in the
X.I termcap
Xfile (see TERMCAP(5) for more details).  When you start up JOVE, it checks
Xto see whether you have your
X.I TERM
Xenvironment variable set.  On most systems that will automatically be set up
Xfor you, but if it's not JOVE will ask you what kind of terminal you are
Xusing.  To avoid having to type this every time you run JOVE you can set your
X.I TERM
Xenvironment variable yourself.  How you do this depends on which shell you
Xare running.  If you are running the C Shell, as most of you are, you type
X.sp 1
X     % setenv TERM
X.I type
X.sp 1
Xand with the Bourne Shell, you type
X.sp 1
X     $ TERM=
X.I type
X; export TERM
X.sp 1
Xwhere
X.I type
Xis the name of the kind of terminal you are using (e.g., vt100).  If
Xneither of these works get somebody to help you.
X.SH INVOKING JOVE
XIf you run JOVE with no arguments you will be placed in an empty buffer,
Xcalled
X.I Main.
XOtherwise, any arguments you supply are considered file names and each is
X"given" its own buffer.  Only the first file is actually read in--reading
Xother files is deferred until you actually try to use the buffers they are
Xattached to.  This is for efficiency's sake: most of the time, when you run
XJOVE on a big list of files, you end up editing only a few of them.
X.LP
XThe names of all of the files specified on the command line are saved in a
Xbuffer, called
X.I *minibuf*.
XThe mini-buffer is a special JOVE buffer that is used when JOVE is prompting
Xfor some input to many commands (for example, when JOVE is prompting for a
Xfile name).  When you are being prompted for a file name, you can type C-N
X(that's Control-N) and C-P to cycle through the list of files that were
Xspecified on the command line.  The file name will be inserted where you are
Xtyping and then you can edit it as if you typed it in yourself.
X.LP
XJOVE recognizes the following switches:
X.TP
X.I -d
XThe following argument is taken to be the name of the current directory.
XThis is for systems that don't have a version of C shell that automatically
Xmaintains the
X.I CWD
Xenvironment variable.  If
X.I -d
Xis not specified on a system without a modified C shell, JOVE will have to
Xfigure out the current directory itself, and that can be VERY slow.  You
Xcan simulate the modified C shell by putting the following lines in your
XC shell initialization file (.cshrc):
X.nf
X.sp 1
X	alias cd        'cd \\!*; setenv CWD $cwd'
X	alias popd      'popd \\!*; setenv CWD $cwd'
X	alias pushd     'pushd \\!*; setenv CWD $cwd'
X.fi
X.TP
X.I +n
XReads the file, designated by the following argument, and positions point at
Xthe
X.I n'th
Xline instead of the (default) 1'st line.  This can be specified more than
Xonce but it doesn't make sense to use it twice on the same file; in that
Xcase the second one wins.
X.TP
X.I -p
XParses the error messages in the file designated by the following argument.
XThe error messages are assumed to be in a format similar to the C compiler,
XLINT, or GREP output.
X.TP
X.I -t
XRuns the
X.I find-tag 
Xcommand on the following argument (see ctags(1)).
X.TP
X.I -w
XDivides the window in two.  When this happens, either the same file is
Xdisplayed in both windows, or the second file in the list is read in and
Xdisplayed in its window.
X.LP
XAs a special case, invoking JOVE with the -r option runs the JOVE recover
Xprogram.  Use this when the system crashes, or JOVE crashes, or you
Xaccidently get logged out while in JOVE.  If there are any buffers to be
Xrecovered, this will find them.  Read the documentation for RECOVER.
X.LP
X.SH GETTING HELP
XOnce in JOVE, there are several commands available to get help.  To execute
Xany JOVE command, you type "<ESC> X command-name" followed by <Return>.  To
Xget a list of all the JOVE commands you type "<ESC> X" followed by "?".  The
X.I describe-bindings
Xcommand can be used to get a list containing each key, and its associated
Xcommand (that is, the command that gets executed when you type that key).
XIf you want to save the list of bindings, you can set the jove variable
X.I send-typeout-to-buffer
Xto ON (using the 
X.I set
Xcommand), and then execute the
X.I describe-bindings
Xcommand.  This will create a buffer and put in it the bindings list it
Xnormally would have printed on the screen.  Then you can save that buffer to
Xa file and print it to use as a quick reference card.  (See VARIABLES below.)
X.LP
XOnce you know the name of a command, you can find out what it does with the
X.I describe-command
Xcommand, which you can invoke quickly by typing "ESC ?".  The
X.I apropos
Xcommand will give you a list of all the command with a specific string in
Xtheir names.  For example, if you want to know the names of all the
Xcommands that are concerned with windows, you can run "apropos" with the
Xkeyword
X.I window.
X.LP
XIf you're not familar with the EMACS command set, it would be worth your
Xwhile to use run TEACHJOVE.  Do do that, just type "teachjove" to your shell
Xand you will be placed in JOVE in a file which contains directions.  I highly
Xrecommend this for beginners; you may save yourself a lot of time and
Xheadaches.
X.SH KEY BINDINGS and VARIABLES
XYou can alter the key bindings in JOVE to fit your personal tastes.  That
Xis, you can change what a key does every time you strike it.  For example,
Xby default the C-N key is bound to the command
X.I next-line
Xand so when you type it you move down a line.  If you want to change a
Xbinding or add a new one, you use the
X.I bind-to-key
Xcommand.  The syntax is "bind-to-key <command> key".
X.LP
XYou can also change the way JOVE behaves in little ways by changing the
Xvalue of some variables with the
X.I set
Xcommand.  The syntax is "set <variable> value", where value is a number or a
Xstring, or "on" or "off", depending on the context.  For example, if you
Xwant JOVE to make backup files, you set the "make-backup-files" variable to
X"on".  To see the value of a variable, use the "print <variable>" command.
X.SH INITIALIZATION
XJOVE automatically reads commands from an initialization file in your HOME
Xdirectory, called ".joverc".  In this file you can place commands that you
Xwould normally type in JOVE.  If you like to rearrange the key bindings and
Xset some variables every time you get into JOVE, you should put them in your
Xinitialization file.  Here are a few lines from mine:
X.nf
X	set match-regular-expressions on
X	auto-execute-command auto-fill /tmp/Re\\|.*drft
X	bind-to-key i-search-forward ^\\
X	bind-to-key i-search-reverse ^R
X	bind-to-key find-tag-at-point ^[^T
X	bind-to-key scroll-down ^C
X	bind-to-key grow-window ^Xg
X	bind-to-key shrink-window ^Xs
X.fi
X(Note that the Control Characters can be either two character sequences
X(e.g. ^ and C together as ^C) or the actual control character.  If you want
Xto use an ^ by itself you must BackSlash it (e.g., bind-to-key grow-window
X^X\\^ binds grow-window to "^X^").
X.SH SOME MINOR DETAILS
XYou should type C-\\ instead of C-S in many instances.  For example, the way
Xto search for a string is documented as being "C-S" but in reality you
Xshould type "C-\\".  This is because C-S is the XOFF character (what gets
Xsent when you type the NO SCROLL key), and clearly that won't work.  The XON
Xcharacter is "C-Q" (what gets sent when you type NO SCROLL again) which is
Xdocumented as the way to do a quoted-insert.  The alternate key for this is
X"C-^" (typed as "C-`" on vt100's and its look-alikes).  If you want to
Xenable C-S and C-Q and you know what you are doing, you can put the line:
X.nf
X	set allow-^S-and-^Q on
X.fi
Xin your initialization file.
X.LP
XIf your terminal has a metakey, JOVE will use it if you turn on the
X"meta-key" variable.  JOVE will automatically turn on "meta-key" if the
XMETAKEY environment variable exists.  This is useful for if you have
Xdifferent terminals (e.g., one at home and one at work) and one has a
Xmetakey and the other doesn't.
X.SH FILES
XLIBDIR/.joverc - system wide initialization file
X.sp 0
X~/.joverc - personal initialization file
X.sp 0
XTMPDIR - where temporary files are stored
X.sp 0
XLIBDIR/teach-jove - the interactive tutorial
X.sp 0
XLIBDIR/portsrv - for running shells in windows (pdp11 only)
X.SH SEE ALSO
X.nf
Xed(1) - for a description of regular expressions
X.sp 0
Xteachjove(1) - for an interactive JOVE tutorial.
X.fi
X.SH DIAGNOSTICS
XJOVE diagnostics are meant to be self-explanatory, but you are advised
Xto seek help whenever you are confused.  You can easily lose a lot of
Xwork if you don't know EXACTLY what you are doing.
X.SH BUGS
XLines can't be more than 1024 characters long.
X.sp 1
XSearches can't cross line boundaries.
X.SH AUTHOR
XJonathan Payne
@//E*O*F doc/jove.nr//
if test 9034 -ne "`wc -c <'doc/jove.nr'`"; then
    echo shar: error transmitting "'doc/jove.nr'" '(should have been 9034 characters)'
fi
fi # end of overwriting check
echo shar: "End of archive 9 (of 13)."
cp /dev/null ark9isdone
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