Return to manual.n CVS log

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

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

1.1     ! root        1: .de eg
        !             2: .ti .5i
        !             3: .sp 1
        !             4: .bo \\$1
        !             5: .sp 1
        !             6: ..
        !             7: .de ks
        !             8: .sp
        !             9: .ta .5i \\$1
        !            10: .in \\$1
        !            11: ..
        !            12: .de dk         \" Describe Key
        !            13: .ti 0
        !            14: \t\\$1\t\c     \" Flow into the paragraph
        !            15: ..
        !            16: .de ke         \" Key list End
        !            17: .in 0
        !            18: ..
        !            19: .nr si 3n
        !            20: .st 2
        !            21: .m1 3
        !            22: .m4 0
        !            23: .he '%''JOVE Manual for UNIX Users'
        !            24: .bs "Introduction"
        !            25: JOVE
        !            26: .fb
        !            27: JOVE stands for Jonathan's Own Version of Emacs.
        !            28: .fe
        !            29: is an advanced, self-documenting, customizable real-time display
        !            30: editor.  It is based on the original EMACS editor written at M.I.T.
        !            31: by Richard Stallman.
        !            32: .fb
        !            33: Although JOVE is meant to be compatible with
        !            34: EMACS, and indeed many of the basic commands are very similar, there
        !            35: are some major differences between the two editors, and you should not
        !            36: rely on their behaving identically.
        !            37: .fe
        !            38: .lp
        !            39: We say that JOVE is a display editor because normally the text being
        !            40: edited is visible on the screen and is updated automatically as you
        !            41: type your commands.
        !            42: .lp
        !            43: We call it a real-time editor because the display is updated very
        !            44: frequently, usually after each character or pair of characters you
        !            45: type.  This minimizes the amount of information you must keep in your
        !            46: head as you edit.
        !            47: .lp
        !            48: We call JOVE advanced because it provides facilities that go beyond
        !            49: simple insertion and deletion: filling of text; automatic indentations
        !            50: of programs; view more than one file at once; and dealing in terms of
        !            51: characters, words, lines, sentences and paragraphs.  It is much easier
        !            52: to type one command meaning "go to the end of the paragraph" than to
        !            53: find the desired spot with repetition of simpler commands.
        !            54: .lp
        !            55: Self-documenting means that at almost any time you can type a key to
        !            56: find out what a command does, or to find all the commands that pertain
        !            57: to a topic.
        !            58: .lp
        !            59: Customizable means that you can change the definition of JOVE commands
        !            60: in little ways.  For example, you can rearrange the command set; if
        !            61: you prefer to use arrow keys for the four basic cursor motion commands
        !            62: (up, down, left and right), you can.  Another sort of customization is
        !            63: writing new commands by combining built in commands.
        !            64: .es
        !            65: .bs "The Organization of the Screen"
        !            66: JOVE divides the screen up into several sections.  The biggest of
        !            67: these sections is used to display the text you
        !            68: are editing.  The terminal's cursor shows the position of \fIpoint\fR,
        !            69: the location at which editing takes place.  While the cursor appears
        !            70: to point \fIat\fR a character, point should be thought of as between
        !            71: characters; it points \fIbefore\fR the character that the cursor
        !            72: appears on top of.  Terminals have only one cursor, and when output is
        !            73: in progress it must appear where the typing is being done.  This
        !            74: doesn't mean that point is moving; it is only that JOVE has no way of
        !            75: showing you the location of point except when the terminal is idle.
        !            76: .lp
        !            77: The lines of the screen are usually available for displaying text but
        !            78: sometimes are pre-empted by typeout from certain commands (such as, a
        !            79: listing of all the editor functions).  Most of the time, output from
        !            80: commands like these is only desired for a short period of time,
        !            81: usually just long enough to glance at it.  When you have finished
        !            82: looking at the output, you can type Space to make your text reappear.
        !            83: (Usually typing a Space inserts itself, but when there is typeout on
        !            84: the screen, it does nothing but get rid of that.) Any other command
        !            85: executes normally, \fIafter\fR redrawing your text.
        !            86: .bs "The Message Line"
        !            87: The bottom line on the screen, called the \fImessage line\fR is
        !            88: reserved for printing messages, and for accepting input from the user,
        !            89: such as file names, or search strings.  When JOVE prompts for input,
        !            90: the cursor will temporarily appear on the bottom line, waiting for you
        !            91: to type a string.  When you have finished typing your input, you can
        !            92: type a Return to send it to JOVE.  If you change your mind about
        !            93: running the command that is waiting for input, you can type ^G to
        !            94: abort, and you can continue with your editing.
        !            95: .lp
        !            96: Sometimes you will see --more-- on the message line.  This happens
        !            97: when typeout from a command is too long to fit in the screen.  It
        !            98: means that if you type a Space the next screenful of typeout will be
        !            99: printed.  If you are not interested, typing anything but a Space will
        !           100: cause the rest of the output to be discarded.  Typing C-G will discard
        !           101: the output and print Aborted where the --more-- was.  Typing any other
        !           102: command will discard the rest of the output and also do the command.
        !           103: .es
        !           104: .bs "The Mode Line"
        !           105: At the bottom of the screen, but above the message line, is the
        !           106: \fImode line\fR.  The mode line format looks like this:
        !           107: .sp 1
        !           108:      \fBJOVE (major minor)   Buffer: bufr  "file" *\fR
        !           109: .sp 1
        !           110: \fImajor\fR is the name of the current \fImajor mode\fR.  At any time,
        !           111: JOVE can be in only one of the possible major modes.  Currently there
        !           112: are only two major modes: Text and C.
        !           113: .lp
        !           114: \fIminor\fR is a list of the minor modes that are turned.  "Fill"
        !           115: means that Auto Fill mode is on; "Save" means Auto Save mode is on;
        !           116: "OvrWt" means that Over Write mode is on.  "Def" means that you are in
        !           117: the process of defining a keyboard macro.  This is not really a mode,
        !           118: but it's useful to be reminded about.
        !           119: .lp
        !           120: \fIbufr\fR is the name of the currently selected \fIbuffer\fR.
        !           121: Each buffer has its own name and holds a file being edited; this is
        !           122: how JOVE can hold several files at once.  But at any given time you
        !           123: are editing only one of them, the \fIselected\fR buffer.  When we
        !           124: speak of what some command does to "the buffer", we are talking about
        !           125: the currently selected buffer.  Multiple buffers makes it easy to
        !           126: switch around between several files, and then it is very useful that
        !           127: the mode line tells you which one you are editing at any time.
        !           128: .lp
        !           129: \fIfile\fR is the name of the file that you are editing.  This is the
        !           130: default file name for commands that expect a file name as input.
        !           131: .lp
        !           132: The star at the end of the mode line means that there are changes in
        !           133: the buffer that have not been saved in the file.  If the file has not
        !           134: been changed since it was read in or saved, there is no star.
        !           135: .es
        !           136: .es
        !           137: .bs "Command Input Conventions"
        !           138: .bs "Notational Conventions for ASCII Characters"
        !           139: In this manual, "Control" characters (that is, characters that are
        !           140: typed with the Control key and some other key at the same time) are
        !           141: represented by "C-" followed by another character.  Thus, C-A is the
        !           142: character you get when you type A with the Control key (sometimes
        !           143: labeled CTRL) down.  Most control characters when present in the JOVE
        !           144: buffer are displayed with a caret; thus, ^A for C-A.  Rubout is
        !           145: displayed as ^?.
        !           146: .es
        !           147: .bs "Commands, Functions, and Variables"
        !           148: JOVE is composed of \fIfunctions\fR, which have long names such as
        !           149: "next-line" and definitions which are programs that perform the
        !           150: editing operations.  Then \fIcommands\fR such as C-N are connected to
        !           151: functions through the \fIcommand dispatch table\fR.  When we say that
        !           152: C-N moves the cursor down a line, we are glossing over a distinction
        !           153: which is unimportant for ordinary use, but essential for simple
        !           154: customization: it is the function next-line which knows how to move
        !           155: down a line, and C-N moves down a line because it is connected to that
        !           156: function.
        !           157: .lp
        !           158: Sometimes the description of a command will say "to change this, set
        !           159: the variable mumble foo".  A variable is a name used to remember a
        !           160: value.  JOVE contains variables which are there so that you can change
        !           161: them if you want to customize.  The variable's value is examined by
        !           162: some command, and changing that value makes the command behave
        !           163: differently.  Until you are interesting in customizing, you can ignore
        !           164: this information.
        !           165: .es
        !           166: .bs "Prefix Characters"
        !           167: Because there are more function names than keys, JOVE provides
        !           168: \fIprefix characters\fR to increase the number of functions that can
        !           169: easily be invoked.  When you type a prefix character JOVE will wait
        !           170: for another character before deciding what to do.  If you wait more
        !           171: than a second or so, JOVE will print the prefix character on the
        !           172: message line and leave the cursor down there until you type your next
        !           173: character.  There are two prefix characters built into JOVE: Escape
        !           174: and Control-X.  How the next character is interpreted depends on which
        !           175: prefix character you typed.  For example, if you type Escape followed
        !           176: by F you'll run forward-word, but if you type Control-X followed by
        !           177: B you'll run select-buffer.
        !           178: .lp
        !           179: To get a list of keys and their associated function, you type ESC X
        !           180: describe-bindings.  If you want to describe a single key, ESC X
        !           181: describe-key will work.
        !           182: .es
        !           183: .es
        !           184: .bs "Basic Editing Commands"
        !           185: .bs "Inserting Text"
        !           186: To insert printing characters into the text you are editing, just type
        !           187: them.  All printing characters your type are inserted into the text at
        !           188: the cursor (that is, at \fIpoint\fR), and the cursor moves forward.
        !           189: Any characters after the cursor move forward too.  If the text in the
        !           190: buffer is FOOBAR, with the cursor before the B, then if you type XX,
        !           191: you get FOOXXBAR, with the cursor still before the B.
        !           192: .lp
        !           193: To correct text you have just inserted, you can use Rubout.  Rubout
        !           194: deletes the character \fIbefore\fR the cursor (not the one that the
        !           195: cursor is on top of or under; that is the character \fIafter\fR the
        !           196: cursor).  The cursor and all characters after it move backwards.
        !           197: Therefore, if you typing a printing character and then type Rubout,
        !           198: they cancel out.
        !           199: .lp
        !           200: To end a line and start typing a new one, type Return.  Return
        !           201: operates by inserting a \fIline-separator\fR, so if you type Return in
        !           202: the middle of a line, you break the line in two.  Because a
        !           203: line-separator is just a single character, you can type Rubout at the
        !           204: beginning of a line to delete the line-separator and join it with the
        !           205: preceding line.
        !           206: .lp
        !           207: If you add too many characters to one line, without breaking it with
        !           208: Return, the line will grow too long to display on one screen line.
        !           209: When this happens, JOVE puts an "!" at the extreme right margin, and
        !           210: doesn't bother to display the rest of the line.  The "!" is not part
        !           211: of your text; conversely, even though you can't see the rest of your
        !           212: line, it's still there, and if you break the line, the "!" will go
        !           213: away.
        !           214: .lp
        !           215: Direct insertion works for printing characters and space, but other
        !           216: characters act as editing commands and do not insert themselves.  If
        !           217: you need to insert a control character, Escape, or Rubout, you must
        !           218: first \fIquote\fR it by typing the Control-Q command first.
        !           219: .es
        !           220: .bs "Moving the Cursor"
        !           221: To do more than insert characters, you have to know how to move the
        !           222: cursor.  Here are a few of the commands for doing that.
        !           223: .ks 1.5i
        !           224: .dk C-A
        !           225: Move to the beginning of the line.
        !           226: .dk C-E
        !           227: Move to the end of the line.
        !           228: .dk C-F
        !           229: Move forward over one character.
        !           230: .dk C-B
        !           231: Move backward over one character.
        !           232: .dk C-N
        !           233: Move down one line, vertically.  If you start in the middle of one
        !           234: line, you end in the middle of the next.
        !           235: .dk C-P
        !           236: Move up one line, vertically.
        !           237: .dk "ESC <"
        !           238: Move to the beginning of your text.
        !           239: .dk "ESC >"
        !           240: Move to the end of your text.
        !           241: .ke
        !           242: .es
        !           243: .bs "Erasing Text"
        !           244: .ks 1.5i
        !           245: .dk Rubout
        !           246: Delete the character before the cursor.
        !           247: .dk C-D
        !           248: Delete the character after the cursor.
        !           249: .dk C-K
        !           250: Kill to the end of the line.
        !           251: .ke
        !           252: .lp
        !           253: You already know about the Rubout command which deletes the character
        !           254: before the cursor.  Another command, Control-D, deletes the character
        !           255: after the cursor, causing the rest of the text on the line to shift
        !           256: left.  If Control-D is typed at the end of a line, that line and the
        !           257: next line are joined together.
        !           258: .lp
        !           259: To erase a larger amount of text, use the Control-K command, which
        !           260: kills a line at a time.  If Control-K is done at the beginning or
        !           261: middle of a line, it kills all the text up to the end of the line.  If
        !           262: Control-K is done at the end of a line, it joins that line and the
        !           263: next line.
        !           264: .es
        !           265: .bs "Files - Saving Your Work"
        !           266: The commands above are sufficient for creating text in the JOVE
        !           267: buffer.  The more advanced JOVE commands just make things easier.  But
        !           268: to keep any text permanently you must put it in a \fIfile\fR.  Files
        !           269: are the objects which UNIX uses for storing data for a length of
        !           270: time.  To tell JOVE to edit text in a file, choose a \fIfilename\fR,
        !           271: such as foo.bar, and type C-X C-R foo.bar<cr>.  This \fIreads\fR
        !           272: the file foo.bar so that its contents appear on the screen for
        !           273: editing.  You can make changes, and then save the file by typing C-X
        !           274: C-S.  This makes the changes permanent and actually changes the file
        !           275: foo.bar.  Until then, the changes are only inside you JOVE, and the
        !           276: file foo.bar is not really changed.  If the file foo.bar doesn't
        !           277: exist, and you want to create it, read it as if it did exist.  When
        !           278: you save your text with C-X C-S the file will be created.
        !           279: .es
        !           280: .es
        !           281: .bs "Giving Numeric Arguments to JOVE Commands"
        !           282: Any JOVE command can be given a \fInumeric argument\fR.  Some commands
        !           283: interpret the argument as a repetition count.  For example, giving an
        !           284: argument of ten to the C-F command (forward-character) moves forward
        !           285: ten characters.  With these commands, no argument is equivalent to an
        !           286: argument of 1.
        !           287: .lp
        !           288: Some commands use the value of the argument, but do something peculiar
        !           289: when there is no argument.  For example, ESC G (goto-line) with an
        !           290: argument \fBn\fR goes to the beginning of the \fBn'th\fR line.  But
        !           291: ESC G with no argument doesn't do anything.
        !           292: .lp
        !           293: The fundamental way of specifying an argument is to use ESC followed
        !           294: by the digits of the argument.  Negative arguments are allowed,
        !           295: although not all of the commands know what to do with one.
        !           296: .lp
        !           297: Typing C-U means do the next command four times.  Two such C-U's
        !           298: multiply the next command by sixteen.  Thus, C-U C-U C-F moves forward
        !           299: sixteen characters.  This is a good way to move forward quickly, since
        !           300: it moves about 1/4 of a line on most terminals.  Other useful
        !           301: combinations are: C-U C-U C-N (move down a good fraction of the
        !           302: screen), C-U C-U C-O (make "a lot" of blank lines), and C-U C-K (kill
        !           303: four lines).
        !           304: .lp
        !           305: There are other, terminal-dependent ways of specifying arguments.
        !           306: They have the same effect but may be easier to type.  If your terminal
        !           307: has a numeric keypad which sends something recognizably different from
        !           308: the ordinary digits, it is possible to program JOVE to to allow use of
        !           309: the numeric keypad for specifying arguments.
        !           310: .es
        !           311: .bs "The Mark and the Region"
        !           312: In general, a command that processes an arbitray part of the buffer
        !           313: must know where to start and where to stop.  In JOVE, such commands
        !           314: usually operate on the text between point and \fIthe mark\fR.  This
        !           315: range of text is called \fIthe region\fR.  To specify a region, you
        !           316: set point to one end of it and mark at the other.  It doesn't matter
        !           317: which one is set first \fIchronologically\fR, or which one comes
        !           318: earlier in the text.
        !           319: .ks 1.5i
        !           320: .dk "C-@"
        !           321: Set the mark where point is.
        !           322: .dk "C-X C-X"
        !           323: Interchange mark and point.
        !           324: .ke
        !           325: .lp
        !           326: For example, if you wish to convert part of the buffer to all
        !           327: upper-case, you can use the C-X C-U command, which operates on the
        !           328: text in the region.  You can first go to the beginning of the text to
        !           329: be capitalized, put the mark there, move to the end, and then type C-X
        !           330: C-U.  Or, you can set the mark at the end of the text, move to the
        !           331: beginning, and then type C-X C-U.  C-X C-U runs the function
        !           332: \fIcase-region-upper\fR, whose name signifies that the region, or
        !           333: everything between point and mark, is to be capitalized.
        !           334: .lp
        !           335: The way to set the mark is with the C-@ command or the C-Space
        !           336: command.  They set the mark where point is.  Then you can move point
        !           337: away, leaving mark behind.
        !           338: .lp
        !           339: Since terminals have only one cursor, there is no way for JOVE to show
        !           340: you where the mark is located.  You have to remember.  The usual
        !           341: solution to this problem is to set the mark and then use it soon,
        !           342: before you forget where it is.  But you can see where the mark is with
        !           343: the command C-X C-X which puts the mark where point was and point
        !           344: where mark was.  The extent of the region is unchanged, but the cursor
        !           345: and point are now at the previous location of the mark.
        !           346: .bs "The Ring of Marks"
        !           347: Aside from delimiting the region, the mark is also useful for
        !           348: remembering a spot that you may want to go back to.  To make this
        !           349: feature more useful, JOVE remembers 16 previous locations of the
        !           350: mark.  Most commands that set the mark push the old mark onto this
        !           351: stack.  To return to a marked location, use C-U C-@.  This moves point
        !           352: to where the mark was, and restores the mark from the stack of former
        !           353: marks.  So repeated use of this command moves point to all of the old
        !           354: marks on the stack, one by one.  Since the stack is actually a ring,
        !           355: enough uses of C-U C-@ bring point back to where it was originally.
        !           356: .lp
        !           357: Some commands whose primary purpose is to move point a great distance
        !           358: take advantage of the stack of marks to give you a way to undo the
        !           359: command.  The best example is ESC <, which moves to the beginning of
        !           360: the buffer.  If there are more than 22 lines between the beginning of
        !           361: the buffer and point, ESC < sets the mark first, so that you can use
        !           362: C-U C-@ or C-X C-X to go back to where you were.  You can change the
        !           363: 22 since it is kept in the variable \fImark-threshold\fR.  By setting
        !           364: it to 0, you can make these commands always set the mark.  By setting
        !           365: it to a very large number you can prevent these commands from ever
        !           366: setting the mark.  If a command desides to set the mark, it prints the
        !           367: message Point Pushed.
        !           368: .es
        !           369: .es
        !           370: .bs "Killing and Moving Text"
        !           371: The most common way of moving or copying text with JOVE is to kill it,
        !           372: and get it back again in one or more places.  This is very safe
        !           373: because the last several pieces of killed text are all remembered, and
        !           374: it is versatile, because the many commands for killing syntactic units
        !           375: can also be used for moving those units.  There are also other ways of
        !           376: moving text for special purposes.
        !           377: .bs "Deletion and Killing"
        !           378: Most commands which erase text from the buffer save it so that you can
        !           379: get it back if you change your mind, or move or copy it to other parts
        !           380: of the buffer.  These commands are known as \fIkill\fR commands.  The
        !           381: rest of the commands that erase text do not save it; they are known as
        !           382: \fIdelete\fR commands.  The delete commands include C-D and Rubout,
        !           383: which delete only one character at a time, and those commands that
        !           384: delete only spaces or line separators.  Commands that can destroy
        !           385: significant amounts of nontrivial data generally kill.  The commands'
        !           386: names and individual descriptions use the words "kill" and "delete" to
        !           387: say which they do.
        !           388: .ks 1.8i
        !           389: .dk C-D
        !           390: Delete next character.
        !           391: .dk Rubout
        !           392: Delete previous character.
        !           393: .dk "ESC \\\\"
        !           394: Delete spaces and tabs around point.
        !           395: .dk "C-X C-O"
        !           396: Delete blank lines around the current line.
        !           397: .dk "C-K"
        !           398: Kill rest of line or one or more lines.
        !           399: .dk "C-W"
        !           400: Kill region (from point to the mark).
        !           401: .dk "ESC D"
        !           402: Kill word.
        !           403: .dk "ESC Rubout"
        !           404: Kill word backwards.
        !           405: .dk "ESC K"
        !           406: Kill to end of sentence.
        !           407: .ke
        !           408: .bs "Deletion"
        !           409: The most basic delete commands are C-D and Rubout.  C-D deletes the
        !           410: character after the cursor, the one the cursor is "on top of" or
        !           411: "underneath".  The cursor doesn't move.  Rubout deletes the character
        !           412: before the cursor, and moves the cursor back.  Line separators act
        !           413: like normal characters when deleted.  Actually, C-D and Rubout aren't
        !           414: always delete commands; if you give an argument, they kill instead.
        !           415: This prevents you from losing a great deal of text by typing a large
        !           416: argument to a C-D or Rubout.
        !           417: .lp
        !           418: The other delete commands are those which delete only formatting
        !           419: characters: spaces, tabs, and line separators.  ESC \\ (delete white
        !           420: space) deletes all the spaces and tab characters before and after
        !           421: point.  C-X C-O (delete blank lines) deletes all blank lines after the
        !           422: current line, and if the current line is blank deletes all the blank
        !           423: lines preceding the current line as well (leaving one blank line, the
        !           424: current line).
        !           425: .es
        !           426: .bs "Killing by Lines"
        !           427: The simplest kill command is the C-K command.  If issued at the
        !           428: beginning of a line, it kills all the text on the line, leaving it
        !           429: blank.  If given on a blank line, the blank line disappears.  As a
        !           430: consequence, if you go to the front of a non-blank line and type two
        !           431: C-K's, the line disappears completely.
        !           432: .lp
        !           433: More generally, C-K kills from point up to the end of the line, unless
        !           434: it is at the end of a line.  In that case, it kills the line separator
        !           435: following the line, thus merging the next line into the current one.
        !           436: Invisible spaces and tabs at the end of the line are ignored when
        !           437: deciding which case applies, so if point appears to be at the end of the
        !           438: line, you can be sure the line separator will be killed.
        !           439: .lp
        !           440: C-K with an argument of zero kills all the text before point on the
        !           441: current line.
        !           442: .es
        !           443: .bs "Other Kill Commands"
        !           444: A kill command which is very general is C-W (kill-region), which kills
        !           445: everything between point and the mark.  With this command, you can
        !           446: kill and contiguous characters, if you first set the mark at one end
        !           447: of them and go to the other end.
        !           448: .lp
        !           449: Other syntactic units can be killed: words, with ESC Rubout and ESC D;
        !           450: sentences, with ESC K.
        !           451: .es
        !           452: .es
        !           453: .bs "Un-killing"
        !           454: Un-killing is getting back text which was killed.  The usual way to
        !           455: move or copy text is to kill it and then un-kill it one or more times.
        !           456: .ks 1.5i
        !           457: .dk C-Y
        !           458: Yank (re-insert) last killed text.
        !           459: .dk "ESC Y"
        !           460: Replace re-inserted killed text with the previously killed text.
        !           461: .dk "ESC W"
        !           462: Save region as last killed text without killing.
        !           463: .ke
        !           464: .lp
        !           465: Killed text is pushed onto a \fIring buffer\fR called the \fIkill
        !           466: ring\fR that remembers the last 10 blocks of text that were killed.
        !           467: (Why it is called a ring buffer will be explained below.) The command
        !           468: C-Y (yank) reinserts the text of the most recent kill.  It leaves the
        !           469: cursor at the end of the text, and puts the mark at the beginning.
        !           470: Thus, a single C-W undoes the C-Y.
        !           471: .lp
        !           472: If you wish to copy a block of text, you might want to use ESC W
        !           473: (copy-region), which copies the region into the kill ring without
        !           474: removing it from the buffer.  This is approximately equivalent to C-W
        !           475: followed by C-Y, except that ESC W does not mark the buffer as
        !           476: "changed" and does not temporarily change the screen.
        !           477: .lp
        !           478: There is only one kill ring, and switching buffers or files has no
        !           479: effect on it.  After visiting a new file, whatever was last killed in
        !           480: the previous file is still on top of the kill ring.  This is important
        !           481: for moving text between files.
        !           482: .bs "Appending Kills"
        !           483: Normally, each kill command pushes a new block onto the kill ring.
        !           484: However, two or more kill commands in a row combine their text into a
        !           485: single entry on the ring, so that a single C-Y command gets it all
        !           486: back as it was before it was killed.  This means that you don't have
        !           487: to kill all the text in one command; you can keep killing line after
        !           488: line, or word after word, until you have killed it all, and you can
        !           489: still get it all back at once.  (Thus we join television in leading
        !           490: people to kill thoughtlessly.)
        !           491: .fe
        !           492: .lp
        !           493: Commands that kill forward from point add onto the end of the previous
        !           494: killed text.  Commands that kill backward from point add onto the
        !           495: beginning.  This way, any sequence of mixed forward and backward kill
        !           496: commands puts all the killed text into one entry without rearrangement.
        !           497: .es
        !           498: .bs "Un-killing Earlier Kills"
        !           499: To recover killed text that is no longer the most recent kill, you
        !           500: need the ESC Y (yank-pop) command.  The ESC Y command should be used
        !           501: only after a C-Y command or another ESC Y.  It takes the un-killed
        !           502: text inserted by the C-Y and replaces it with the text from an earlier
        !           503: kill.  So, to recover the text of the next-to-the-last kill, you first
        !           504: use C-Y to recover the last kill, and then use ESC Y to move back to
        !           505: the previous kill.
        !           506: .lp
        !           507: You can think of all the last few kills as living on a ring.  After a
        !           508: C-Y command, the text at the front of the ring is also present in the
        !           509: buffer.  ESC Y "rotates" the ring bringing the previous string of text
        !           510: to the front, and this text replaces the other text in the buffer as
        !           511: well.  Enough ESC Y commands can rotate any part of the ring to the
        !           512: front, so you can get at any kiled text solong as it is recent enough
        !           513: to be still in the ring.  Eventually the ring rotates all the way
        !           514: around and the most recent killed text comes to the front (and into
        !           515: the buffer) again.  ESC Y with a negative argument rotates the ring
        !           516: backwards.
        !           517: .lp
        !           518: When the text you are looking for is brought into the buffer, you can
        !           519: stop doing ESC Y's and it will stay there.  It's really just a copy of
        !           520: what's in at the front of the ring, so editing it does not change
        !           521: what's in the ring.  And the ring, once rotated, stays rotated, so
        !           522: that doing another C-Y gets another copy of what you rotated to the
        !           523: fron with ESC Y.
        !           524: .lp
        !           525: If you change you mind about un-killing, and C-W gets rid of the
        !           526: un-killed text at any point, after any number of ESC Y's.  C-W pushes
        !           527: the text onto the ring again.
        !           528: .es
        !           529: .es
        !           530: .es
        !           531: .bs "Searching"
        !           532: The search commands are useful for finding and moving to arbitrary
        !           533: positions in the buffer in one swift motion.  For example, if you just
        !           534: ran the spell program on a paper and you want to correct some word,
        !           535: you can use the search commands to move directly to that word.
        !           536: .bs "Conventional Search"
        !           537: .ks 1.5i
        !           538: .dk "C-S"
        !           539: Search forward.
        !           540: .dk "C-R"
        !           541: Search backward.
        !           542: .ke
        !           543: .lp
        !           544: To search for the string "FOO" you type "C-S FOO<CR>".  If JOVE finds
        !           545: FOO it moves point to the end of it; otherwise JOVE prints an error
        !           546: message and leaves point unchanged.  C-S searches forward from point
        !           547: so only occurrences of FOO after point are found.  To search in the
        !           548: other direction use C-R.  It is exactly the same as C-S except it
        !           549: searches in the opposite direction, and if it finds the string, it
        !           550: leaves point at the beginning of it, not at the end as in C-S.
        !           551: .lp
        !           552: While JOVE is searching it prints the search string on the message
        !           553: line line.  This is so you know what JOVE is doing.  When the system
        !           554: is heavily loaded, when editing in exceptionally large buffers,
        !           555: searches can take several (sometimes many) seconds.
        !           556: .lp
        !           557: JOVE remembers the last search string you used, so if you want to
        !           558: search for the same string you can type "C-S <cr>".  If you mistyped
        !           559: the last search string, you can type C-S followed by C-R.  C-R, as
        !           560: usual inserts the default search string into the minibuffer, and then
        !           561: you can fix it up.
        !           562: .es
        !           563: .bs "Incremental Search"
        !           564: This search command is unusual in that is is \fIincremental\fR; it
        !           565: begins to search before you have finished typing the search string.
        !           566: As you type in the search string, JOVE shows you where it would be
        !           567: found.  WHen you have typed enough characters to identify the place
        !           568: you want, you can stop.  Depending on what you will do next, you may
        !           569: or may not need to terminate the search explicitly with a Return
        !           570: first.
        !           571: .lp
        !           572: The command to search is C-S (i-search-forward).
        !           573: .fb
        !           574: It is assumed that your JOVE has i-search-forward bound to C-S and
        !           575: i-search-reverse bound to C-R.  These are not the default bindings.
        !           576: .fe
        !           577: C-S reads in characters and positions the cursor at the first
        !           578: occurrence of the characters that you have typed.  If you type C-S and
        !           579: then F, the cursor moves right after the first "F".  Type an "O", and
        !           580: see the cursor move to after the first "FO".  After another "O", the
        !           581: cursor is after the first "FOO" after the place where you started the
        !           582: search.  At the same time, the "FOO" has echoed on the message line.
        !           583: .lp
        !           584: If you type a mistaken character, you can rub it out.  After the FOO,
        !           585: typing a Rubout makes the "O" disappear from the message line, leaving
        !           586: only "FO".  The cursor moves back to the "FO".  Rubbing out the "O"
        !           587: and "F" moves the cursor back to where you started the search.
        !           588: .lp
        !           589: When you are satisfied with the place you have reached, you can type a
        !           590: Return, which stops searching, leaving the cursor where the search
        !           591: brought it.  Also, any command not specially meaningful in searches
        !           592: stops the searching and is then executed.  Thus, typing C-A would exit
        !           593: the search and then move to the beginning of the line.  Return is
        !           594: necessary only of the next character you want to type is a printing
        !           595: character, Rubout, Return, or another search command, since those ar
        !           596: ethe characters that have special meanings inside the search.
        !           597: .lp
        !           598: Sometimes you search for "FOO" and find it, but not the one you
        !           599: expected to find.  There was a second FOO that you forgot about,
        !           600: before the one you were looking for.  Then type another C-S and the
        !           601: cursor will find the next FOO.  This can be done any number of times.
        !           602: If you overshoot, you can rub out the C-S's.
        !           603: .lp
        !           604: After you exist a search, you can search for the same string again by
        !           605: typing just C-S C-S: one C-S command to start the search and then
        !           606: another C-S to mean "search again".
        !           607: .lp
        !           608: If your string is not found at all, the message line says "Failing
        !           609: I-search".  The cursor is after the place where JOVE found as much of
        !           610: your string as it could.  Thus, if you search for FOOT, and there is
        !           611: not FOOT, you might see the cursor after the FOO in FOOL.  At this
        !           612: point there are several things you can do.  If your string was
        !           613: mistyped, you can rub some of it out and correct it.  If you like the
        !           614: places you have found, you can type Return or some other JOVE command
        !           615: to "accept what the search offered".  Or you can type C-G, which
        !           616: undoes the search altogether and positions you back where you started
        !           617: the search.
        !           618: .lp
        !           619: You can also type C-R at any time to start searching backwards.  If a
        !           620: search fails because the place you started was too late in the file,
        !           621: you should do this.  Repeated C-R's keep looking formore occurrences
        !           622: backwards.  A C-S starts going forwards again.  C-R's can be rubbed
        !           623: out just like anything else.  If you know that you want to start
        !           624: search backwards, you can use C-R (i-search-reverse) to search
        !           625: backward.
        !           626: .es
        !           627: .bs "Regular Expressions Search Strings"
        !           628: I couldn't describe them if I tried!
        !           629: .es
        !           630: .es
        !           631: .bs "Commands for English Text"
        !           632: .bs "Word Commands"
        !           633: JOVE has commands for moving over or operating on words.  By
        !           634: convention, they are all ESC commands.
        !           635: .ks 1.7i
        !           636: .dk "ESC F"
        !           637: Move Forward over a word.
        !           638: .dk "ESC B"
        !           639: Move Backward over a word.
        !           640: .dk "ESC D"
        !           641: Kill up to the end of a word.
        !           642: .dk "ESC Rubout"
        !           643: Kill up to the beginning of a word.
        !           644: .dk "ESC T"
        !           645: Transpose two words; drag a word forward or backward across other words.
        !           646: .ke
        !           647: .lp
        !           648: Notice how these commands form a group that parallels the character
        !           649: base commands, C-F, C-B, C-D, Rubout, and C-T.
        !           650: .lp
        !           651: The commands ESC F and ESC B move forward and backward over words.
        !           652: They are thus analogous to Control-F and Control-B, which move over
        !           653: single characters.  Like their Control- analogues, ESC F and ESC B
        !           654: move several words if given an argument.  ESC F with a negative
        !           655: argument moves backward like ESC B, and ESC B with a negative argument
        !           656: moves forward.  Forward motion stops right after the last letter of
        !           657: the word, while backward motion stops right before the first letter.
        !           658: .lp
        !           659: It is easy to kill a word at a time.  ESC D kills the word after
        !           660: point.  To be precise, it kills everything from point to the place ESC
        !           661: F would move to.  Thus, if point is in the middle of a word, only the
        !           662: part after point is killed.  If some punctuation comes after point,
        !           663: and before the next word, it is killed along with the word.  If you
        !           664: wish to kill only the next word but not the punctuation, simply do ESC
        !           665: F to get to the end, and kill the word backwards with ESC Rubout.  ESC
        !           666: D takes arguments just like ESC F.
        !           667: .lp
        !           668: ESC Rubout kills the word before point.  It kills everything from
        !           669: point back to where ESC B would move to.  If point is after the space
        !           670: int "FOO, BAR", then "FOO, " is killed.  If you wish to kill just
        !           671: "FOO", then do a ESC B and a ESC D instead of a ESC Rubout.
        !           672: .es
        !           673: .bs "Sentence and Paragraph Commands"
        !           674: The JOVE commands for manipulating sentences and paragraphs are
        !           675: entirely ESC commands, so as to resemble the word-handling commands.
        !           676: .ks 1.7i
        !           677: .dk "ESC A"
        !           678: Move back to the beginning of the sentence.
        !           679: .dk "ESC E"
        !           680: Move forward to the end of the sentence.
        !           681: .dk "ESC K"
        !           682: Kill forward to the end of the sentence."
        !           683: .dk "ESC ["
        !           684: Move back to previous paragraph beginning.
        !           685: .dk "ESC ]"
        !           686: Move forward to next paragraph end.
        !           687: .dk "C-X Rubout"
        !           688: Kill back to the beginning of the sentence.
        !           689: .ke
        !           690: .bs Sentences
        !           691: The commands ESC A and ESC E move to the beginning and end of the
        !           692: current sentence, respectively.  They were chosen to resemble
        !           693: Control-A and Control-E, which move to the beginning and end of a
        !           694: line.  Unlike them, ESC A and ESC E if repeated or given numeric
        !           695: arguments move over successive sentences.  JOVE considers a sentence
        !           696: to end wherever there is a ".", "?", or "!" followed by the end of a
        !           697: line, or one or more spaces.  Neither ESC A nor ESC E moves past the
        !           698: end of the line or spaces which delimit the sentence.
        !           699: .lp
        !           700: Just as C-A and C-E have a kill command, C-K, to go with them, so ESC
        !           701: A and ESC E have a corrisponding kill command ESC K which kills from
        !           702: point to the end of the sentence.  With minus one as an argument it
        !           703: kills back to the beginning of the sentence.  Larger arguments serve
        !           704: as a repeat count.
        !           705: .lp
        !           706: There is a special command, C-X Rubout for killing back to the
        !           707: beginning of a sentence, because this is useful when you change your
        !           708: mind in the middle of composing text.
        !           709: .es
        !           710: .bs Paragraphs
        !           711: ESC [ moves to the beginning of the current or previous paragraph,
        !           712: while ESC ] moves to the end of the current or next paragraph.  Blank
        !           713: lines and text justifier command lines separate paragraphs and are not
        !           714: part of any paragraph.  Also, an indented line starts a new
        !           715: paragraph.  A line beginning with a letter which can't be part of a
        !           716: word, e.g., period, singlequote, "-", "\\", it is considered a
        !           717: paragraph terminator.
        !           718: .es
        !           719: .es
        !           720: .bs Indentation Commands for Text
        !           721: .ks 1.7i
        !           722: .dk "Tab"
        !           723: Indent "appropriately" in a mode-dependent fashion.
        !           724: .dk "LineFeed"
        !           725: Is the same as Return, except it copies the indent of the line you
        !           726: just left.
        !           727: .dk "ESC M"
        !           728: Moves to the line's first non-blank character.
        !           729: .ke
        !           730: .lp
        !           731: The way to request indentation is with the Tab command.  Its precise
        !           732: effect depends on the major mode.  In Text mode, it indents to the
        !           733: next tab stop.  In C mode, it indents to the "right" position for C
        !           734: programs.
        !           735: .lp
        !           736: To move over the indentation on a line, do ESC M.  This command, given
        !           737: anywhere on a line, positions the cursor at the first nonblank
        !           738: character on the line.
        !           739: .es
        !           740: .bs "Text Filling"
        !           741: auto-fill mode lets you type in text that is \fIfilled\fR (broken up
        !           742: into lines that fit ina specified width) as you go.  If you alter
        !           743: existing text and this cause it to cease to be properly filled, JOVE
        !           744: can fill it again if you ask.
        !           745: .lp
        !           746: Entering auto-fill mode is done with ESC X auto-fill.  From then on,
        !           747: lines are broken automatically at spaces when they get longer than the
        !           748: desired width.  To leave auto-fill mode, execute ESC X auto-fill
        !           749: again.  When auto-fill mode is in effect, the word "Fill" appears in
        !           750: the mode line.
        !           751: .lp
        !           752: If you edit the middle of a paragraph, it may no longer correctly be
        !           753: filled.  To refill a paragraph, use the command ESC J.  It causes the
        !           754: paragraph that point is inside to be filled.  All the line breaks are
        !           755: removed and then new ones are inserted where necessary.
        !           756: .lp
        !           757: The maximum line width for filling is in the variable right-margin.
        !           758: Both ESC J and auto-fill make sure that no line exceeds this width.
        !           759: right-margin is initially 72.
        !           760: .es
        !           761: .bs "Case Conversion Commands"
        !           762: .ks 1.5i
        !           763: .dk "ESC L"
        !           764: Convert following word to lower case.
        !           765: .dk "ESC U"
        !           766: Convert following word to upper case.
        !           767: .dk "ESC C"
        !           768: Capitalize the following word.
        !           769: .ke
        !           770: .lp
        !           771: The word conversion commands are most useful.  ESC L converts the word
        !           772: after point to lower case, moving past it.  This, successive ESC L's
        !           773: convert successive words.  ESC U converts to all capitals instead,
        !           774: while ESC C puts the first letter of the word into upper case and the
        !           775: rest into lower case.  All these commands convert several words at
        !           776: once if given an argument.  They are especially convenient for
        !           777: converting a large amount of text from all upper case to mixed case,
        !           778: because you can move through the test using ESC L, ESC U or ESC C on
        !           779: each word as appropriate.
        !           780: .lp
        !           781: When given a negative argument, the word case conversion commands
        !           782: apply to the appropriate number of words before point, but do not move
        !           783: point.  This is convenient when you have just typed a word in the
        !           784: wrong case.  You can give the case conversion command and continue
        !           785: typing.
        !           786: .lp
        !           787: If a word case conversion command is given in the middle of a word, it
        !           788: applies only to the part of the word which follows the cursor,
        !           789: treating it as a whole word.
        !           790: .lp
        !           791: The other case conversion functions are case-region-upper and
        !           792: case-region-lower, which convert everything between point and mark to
        !           793: the specified case.  Point and mark do not move.
        !           794: .es
        !           795: .es
        !           796: .bs "Commands for Fixing Typos"
        !           797: In this section we describe the commands that are especially useful
        !           798: for the times when you catch a mistake on your text after you have
        !           799: made it, or change your mind while composing text on line.
        !           800: .ks 2.2i
        !           801: .dk "Rubout"
        !           802: Delete last character.
        !           803: .dk "ESC Rubout"
        !           804: Kill last word.
        !           805: .dk "C-X Rubout"
        !           806: Kill to beginning of sentence.
        !           807: .dk "C-T"
        !           808: Transpose two characters.
        !           809: .dk "C-X C-T"
        !           810: Transpose two lines.
        !           811: .dk "ESC Minus ESC L"
        !           812: Convert last word to lower case.
        !           813: .dk "ESC Minus ESC U"
        !           814: Convert last word to upper case.
        !           815: .dk "ESC Minus ESC C"
        !           816: Convert last word to lower case with capital initial.
        !           817: .ke
        !           818: .bs "Killing Your Mistakes"
        !           819: The Rubout command is the most important correction command.  When
        !           820: used among printing (self-inserting) characters, it can be thought of
        !           821: as canceling the last character typed.
        !           822: .lp
        !           823: When your mistake is longer than a couple of characters, it might be
        !           824: more convenient to use ESC Rubout or C-X Rubout.  ESC Rubout kills
        !           825: back to the start of the last word, and C-X Rubout kills back to the
        !           826: start of the last sentence.  C-X Rubout is particularly useful when
        !           827: you are thinking of what to write as you type it, in case you change
        !           828: your mind about phrasing.  ESC Rubout and C-X Rubout save the killed
        !           829: text for C-Y and ESC Y to retrieve.
        !           830: .lp
        !           831: ESC Rubout is often useful even when you have typed only a few
        !           832: characters wrong, if you know you are confused in your typing and
        !           833: aren't sure what you typed.  At such a time, you cannot correct with
        !           834: Rubout except by looking at the screen to see what you did.  It
        !           835: requires less thought to kill the whole word and start over again,
        !           836: especially if the system is heavily loaded.
        !           837: .es
        !           838: .bs "Transposition"
        !           839: The command error of transposing two characters can be fixed, when
        !           840: they are adjacent, with the C-T command.  Normally, C-T transposes the
        !           841: two characters on either side of the cursor.  When given at the end of
        !           842: a line, rather than switching the last character of the line with the
        !           843: line separator, which would be useless, C-T transposees the last two
        !           844: characters on the line.  So, if you catch your transposition error
        !           845: right away, you can fix it with just a C-T.  If you don't catch it so
        !           846: fast, you must move the cursor back to between the two characters.
        !           847: .lp
        !           848: To transpose two lines, use the C-X C-T command.
        !           849: .es
        !           850: .bs "Checking and Correcting Spelling"
        !           851: When you write a paper, you should correct its spelling at some point
        !           852: close the finishing it.  To correct the entire buffer, do ESC X
        !           853: spell-buffer.  This invokes the UNIX spell program, which prints a list
        !           854: of all the misspelled words.  JOVE catches the list and places it in a
        !           855: JOVE buffer called Spell, and then looks up each misspelled word and
        !           856: remembers where it is in the buffer being corrected.  Then you can go
        !           857: forward to each misspelled word with C-X C-N (next-error) and backward
        !           858: with C-X C-P (previous-error).  See error parsing.
        !           859: .es
        !           860: .es
        !           861: .bs "File Handling"
        !           862: The basic unit of stored data is the file.  Each program, each paper,
        !           863: lives usually in its own file.  To edit a program or paper, the editor
        !           864: must be told the name of the file that contains it.  This is called
        !           865: \fIvisiting\fR a file.  To make your changes to the file perminent on
        !           866: disk, you must \fIsave\fR the file.
        !           867: .bs "Visiting Files"
        !           868: .ks 1.5i
        !           869: .dk "C-X C-V"
        !           870: Visit a file.
        !           871: .dk "C-X C-R"
        !           872: Same as C-X C-V.
        !           873: .dk "C-X C-S"
        !           874: Save the visited file.
        !           875: .dk "ESC ~"
        !           876: Tell JOVE to forget that the buffer has been changed.
        !           877: .ke
        !           878: .lp
        !           879: \fIVisiting\fR a file means copying its contents into JOVE where you
        !           880: can edit them.  JOVE remembers the name of the file you visited.
        !           881: Unless you use the multiple buffer or window features of JOVE, you can
        !           882: only be visiting one file at a time.  The name of the current selected
        !           883: buffer is visible in the mode line.
        !           884: .lp
        !           885: The changes you make with JOVE are made in a copy inside JOVE.  The
        !           886: file itself is not changed.  The changed test is not permanent until
        !           887: you \fIsave\fR it in a file.  The first time you change the text, a
        !           888: star appears at the end of the mode line; this indicates that the text
        !           889: contains fresh changes which will be lost unless you save them.
        !           890: .lp
        !           891: To visit a file, use the command C-X C-V.  Follow the command with the
        !           892: name of the file you wish to visit, terminated by a Return.  You can
        !           893: abort the command by typing C-G, or edit the filename with the many of
        !           894: the standard JOVE commands (e.g., C-A, C-E, C-F, ESC F, ESC Rubout).
        !           895: If the filename you wish to visit is similar to the filename in the
        !           896: mode line (the default file name), you can type C-R to insert the
        !           897: default and then edit it.  If you do type a Return to finish the
        !           898: command, the new file's text appears on the screen, and its name
        !           899: appears in the mode line.  In addition, its name becomes the new
        !           900: default filename.
        !           901: .lp
        !           902: If you wish to save the file and make your changes permanent, type C-X
        !           903: C-S.  After the save is finished, C-X C-S prints the filename and the
        !           904: number of characters and lines that it wrote to the file.  If there
        !           905: are no changes to save (no star at the end of the mode line), the file
        !           906: is not saved; otherwise the changes saved and the star at the end of
        !           907: the mode line will disappear.
        !           908: .lp
        !           909: Because a system crash can cause you to lose everything you have done
        !           910: since the last save, we provide auto-save mode, which saves the files
        !           911: you are visiting at regular intervals automatically.  See auto-save.
        !           912: .lp
        !           913: What if you want to create a file?  Just visit it.  JOVE prints "(New
        !           914: file)" but aside from that behaves as if you had visited an existing
        !           915: empty file.  If you make any changes and save them, the file is
        !           916: created.  If you visit a nonexistent file unintentionally (because you
        !           917: typed the wrong filename), go ahead and visit the file you meant.  If
        !           918: you don't save the unwanted file, it is not created.
        !           919: .lp
        !           920: If you alter one file and then visit another in the same buffer, JOVE
        !           921: offers to save the old one.  If you answer YES, the old file is saved;
        !           922: if you answer NO, all the changes you have made to it since the last
        !           923: save are lost.  You should not type ahead after a file visiting
        !           924: command, because your type-ahead might answer an unexpected question
        !           925: in a way that you would regret.
        !           926: .lp
        !           927: Sometimes you will change a buffer by accident.  Even if you undo the
        !           928: change by hand, JOVE still knows that "the buffer has been changed".
        !           929: You can tell JOVE to belive that there have been no changes with the
        !           930: ESC ~ command.  This command simply clears the "modified" flag which
        !           931: says that the buffer contains changes which need to be saved.  Even if
        !           932: the buffer really \fIis\fR changed JOVE will still act as if it were
        !           933: not.
        !           934: .lp
        !           935: If JOVE is about to save a file and sees that the date of the version
        !           936: on disk does not match what JOVE last read or wrote, JOVE notifies you
        !           937: of this fact, and asks what to do, because this probably means that
        !           938: something is wrong.  For example, somebody else may have been editing
        !           939: the same file.  If this is so, there is a good chance that your work
        !           940: or his work will be lost if you don't take the proper steps.  You
        !           941: should first find out exactly what is going on.  If you determine that
        !           942: somebody else has modified the file, save your file under a different
        !           943: name and then DIFF the two files to merge the two sets of changes.
        !           944: Also get in touch with the other person so that he doesn't continue
        !           945: editing.
        !           946: .es
        !           947: .bs "How to Undo Drastic Changes to a File"
        !           948: If you have made several extensive changes to a file and then change
        !           949: your mind about them, and you haven't yet saved them, you can get rid
        !           950: of them by reading in the previous version of the file.  You can do
        !           951: this with the C-X C-V command, to visit the unsaved version of the file.
        !           952: .es
        !           953: .bs "Auto Save Mode"
        !           954: In auto-save mode, JOVE saves your file from time to time (based on
        !           955: counting your commands) without being asked.  This prevents you from
        !           956: losing more than a limited amount of work in a disaster.
        !           957: .lp
        !           958: You can turn auto saving on or off in an individual buffer with ESC X
        !           959: auto-save.  In addition, you can have auto savng by default in all
        !           960: buffers by putting the auto-save line in your initialization file.
        !           961: See initialization files.  The frequency of saving can be specified.
        !           962: .lp
        !           963: Once you have visited a file, you can turn auto saving on or off with
        !           964: ESC X auto-save.  Line other minor mode commands, ESC X auto-save
        !           965: toggles.  If you start typing a new file into a buffer without
        !           966: visiting anything, auto-save mode is initially off, but you can turn
        !           967: it on with ESC X auto-save.
        !           968: .lp
        !           969: When JOVE decides to do an auto-save, it doesn't save it under the
        !           970: name you have visited; instead it saves it under some special "auto
        !           971: save file name".  This file name will be the same as your visited file
        !           972: name except for having "+" appended to it.  An error in the process of
        !           973: auto saving prints "(Auto Save Error!)".  When you leave the editor
        !           974: normally, all auto saved files are removed.  However, if there is an
        !           975: internal error or the system crashes, the save files will not be
        !           976: removed so that you salvage your work.
        !           977: .lp
        !           978: If you want to save your file "for real", use C-X C-S, as always.
        !           979: .es
        !           980: .bs "Miscellaneous File Operations"
        !           981: .lp
        !           982: ESC X write-named-file <file><cr> writes the contents of the buffer
        !           983: into the file <file>, and then visits that file.  It can be thought of
        !           984: as a way of "changing the name" of the file you are visiting.  Unlike
        !           985: C-X C-S, write-file saves even if the buffer has not been changed.
        !           986: C-X C-W is another way of getting this command.
        !           987: .lp
        !           988: ESC X insert-file <file><cr> inserts the contents of <file> into the
        !           989: buffer at point, leaving point unchanged before the contents.  You can
        !           990: also use C-X C-I to get this command.
        !           991: .lp
        !           992: ESC X write-region <file><cr> writes the region (the text between
        !           993: point and mark) to the specified file.  It does not set the visited
        !           994: filenames.  The buffer is not changed.
        !           995: .lp
        !           996: ESC X append-region <file><cr> appends the region to <file>.  The text
        !           997: is added to the end of <file>.
        !           998: .es
        !           999: .es
        !          1000: .bs "Using Multiple Buffers"
        !          1001: When we speak of "the buffer", which contains the text you are
        !          1002: editing, we have given the impression that there is only one.  In
        !          1003: fact, there may be many of them, each with its own body of text.  At
        !          1004: any time only one buffer can be \fIselected\fR and available for
        !          1005: editing, but it isn't hard to switch to a different one.  Each buffer
        !          1006: individually remembers which file it is visiting, what modes are in
        !          1007: effect, and whether there are any changes that need saving.
        !          1008: .ks 1.3i
        !          1009: .dk "C-X B"
        !          1010: Select or create a buffer.
        !          1011: .dk "C-X C-F"
        !          1012: Visit a file in its own buffer.
        !          1013: .dk "C-X C-B"
        !          1014: List the existing buffers.
        !          1015: .dk "C-X K"
        !          1016: Kill a buffer.
        !          1017: .ke
        !          1018: .lp
        !          1019: Each buffer in JOVE has a single name, which normally doesn't change.
        !          1020: A buffer's name can be anylength.  The name of the currently selected
        !          1021: buffer, and the name of the file visited in it, are visible in the
        !          1022: mode line when you are at top level.  A newly started JOVE has only
        !          1023: one buffer, named "Main".
        !          1024: .bs "Creating and Selecting Buffers"
        !          1025: To create a new buffer, you need only think of a name for it (say,
        !          1026: FOO) and then do C-X B FOO<cr>, which is the command C-X B
        !          1027: (select-buffer) followed by the name.  This makes a new, empty buffer
        !          1028: and selects it for editing.  The new buffer is not visiting any file,
        !          1029: so if you try to save it you will be asked for the filename to use.
        !          1030: Each buffer as its own major mode; the new buffer's major mode is
        !          1031: always Text mode.
        !          1032: .lp
        !          1033: To return to buffer FOO later after hacing switched to another, the
        !          1034: same command C-X B FOO<cr> is used, since C-X B can atell whether a
        !          1035: buffer named FOO exists already or not.  C-X B Main<cr> reselects the
        !          1036: buffer Main that JOVE started out with.  Just C-X B<cr> reselects the
        !          1037: previous buffer.  Repeated C-X B<cr>'s alternate between the last two
        !          1038: buffers selected.
        !          1039: .lp
        !          1040: You can also read a file into its own newly created buffer, all with
        !          1041: one command: C-X C-F (find-file), followed by the filename.  The name
        !          1042: of the buffer is the last name in the element of the file's pathname.
        !          1043: C-F stands for "Find", because if the specified file already resides
        !          1044: in a buffer in your JOVE, that buffer is reselected.  So you need not
        !          1045: remember whether you have brought the file in already or not.  A
        !          1046: buffer created by C-X C-F can be reslected later with C-X B or C-X
        !          1047: C-F, whichever you find more convenient.  Nonexistent files can be
        !          1048: created with C-X C-F just as they can with C-X C-V.
        !          1049: .es
        !          1050: .bs "Using Existing Buffers"
        !          1051: To get a list of all the buffers that exist, do C-X C-B
        !          1052: (list-buffers).  Each buffer's type, name, and visited
        !          1053: filenames are printed.  A star before the buffer name indicates a
        !          1054: buffer which contains changes that hav enot been saved.  The number
        !          1055: that appears at the beginning of a line in a C-X C-B listing is that
        !          1056: buffer's \FIbuffer number\fR.  You can select a buffer by typing its
        !          1057: number in place of its name.  If a buffer with that number doesn't
        !          1058: already exist, a new buffer is created with that number as its name.
        !          1059: .lp
        !          1060: If several buffers have stars, you should save some of them with C-X
        !          1061: C-M (write-modified-files).  This finds all the buffers that need
        !          1062: saving and then saves them.  Saving the buffers this way is much
        !          1063: easier and more efficient than selecting each one and typing C-X C-S.
        !          1064: If a numeric argument is supplied, it asks whether to save each buffer,
        !          1065: individually.
        !          1066: .lp
        !          1067: ESC X rename-buffer <new name><cr> changes the name of the currently
        !          1068: selected buffer.
        !          1069: .lp
        !          1070: ESC X erase-buffer<buffer name><cr> erases the contents of the <buffer
        !          1071: name> without deleting the buffer entirely.
        !          1072: .es
        !          1073: .bs "Killing Buffers"
        !          1074: After you use a JOVE for a while, it may fill up with buffers which
        !          1075: you no longer need.  Eventually you can reach a point where trying to
        !          1076: create any more results in an "out of memory" or "out of lines"
        !          1077: error.  When this happens you will want to kill some buffers with the
        !          1078: C-X K (delete-buffer) command.  You can kill the buffer FOO by doing
        !          1079: C-X K FOO<cr>.  If you type C-X K <cr> JOVe will kill the previously
        !          1080: selected buffer.  If you try to kill a buffer that needs saving JOVE
        !          1081: will ask you to confirm it.
        !          1082: .es
        !          1083: .es
        !          1084: .bs "Controlling the Display"
        !          1085: Since only part of a large file fits on the screen, JOVE tries to show
        !          1086: the part that is likely to be interesting.  The display control
        !          1087: commands allow you to see a different part of the file.
        !          1088: .ks 1.5i
        !          1089: .dk "C-L"
        !          1090: Reposition point at a specified vertical position, OR clear and redraw
        !          1091: the screen with point in the same place.
        !          1092: .dk "C-V"
        !          1093: Scroll forwards (a screen or a few lines).
        !          1094: .dk "ESC V"
        !          1095: Scroll backwards.
        !          1096: .dk "C-Z"
        !          1097: Scroll forward some lines.
        !          1098: .dk "ESC Z"
        !          1099: Scroll backwards some lines.
        !          1100: .dk "ESC ,"
        !          1101: Beginning of screen.
        !          1102: .dk "ESC ."
        !          1103: End of screen.
        !          1104: .ke
        !          1105: .lp
        !          1106: The terminal screen is rarely large enough to display all of your
        !          1107: file.  If the whole buffer doesn't fit on the screen, JOVE shows a
        !          1108: contiguous portion of it, containing point.  It continues to show
        !          1109: approximately the same portion until point moves outside of it; then
        !          1110: JOVE chooses a new portion centered the new point.  This is JOVE's
        !          1111: guess as to what you are most interested in seeing.  But if the guess
        !          1112: is wrong, you can use the display control commands to see a different
        !          1113: portion.  The finite area of screen through which you can see part of
        !          1114: the buffer is called \fIthe window\fR, and the choice of where in the
        !          1115: buffer to start displaying is also called \fIthe window\fR.
        !          1116: .lp
        !          1117: First we describe how JOVE chooses a new window position on its own.
        !          1118: The goal is usually to place point half way down the screen.  This is
        !          1119: controlled by the variable scroll-step, whose value is the number of
        !          1120: lines above the bottom or below the top of the window that the line
        !          1121: containing point is placed.  A value of 0 (the initial value) means
        !          1122: center the screen.
        !          1123: .lp
        !          1124: The basic display control command is C-L (redraw-display).  In its
        !          1125: simplest form, with no argument, it tells JOVE to choose a new window
        !          1126: position, centering point half way from the top as usual.
        !          1127: .lp
        !          1128: C-L with a positive argument chooses a new window so as to point point
        !          1129: that many lines from the top.  An argument of zero puts point on the
        !          1130: very top line.  Point does not move with respect to the text; rather,
        !          1131: the text and point move rigidly on the screen.
        !          1132: .lp
        !          1133: If point stays on the same line, the screen is first cleared and then
        !          1134: redrawn.  Thus, two C-L's in a row are guarenteed to clear the screen.
        !          1135: .lp
        !          1136: The \fIscrolling\fR commands C-V, ESC V, C-Z, and ESC Z, let you move
        !          1137: the whole display up or down a few lines.  C-V (next-page) with an
        !          1138: argument shows you that many more lines at the bottom of the screen,
        !          1139: moving the text and point up together as C-L might.  C-V with a
        !          1140: negative argument shows you more lines at the top of the screen, as
        !          1141: does ESC V with a positive argument.
        !          1142: .lp
        !          1143: To read the buffer a screenful at a time, use the C-V command with no
        !          1144: argument.  It takes the last line at the bottom of the screen and puts
        !          1145: it at the top, followed by nearly a whole screenful of lines not
        !          1146: visible before.  Point is put at the top of the screen.  Thus, each
        !          1147: C-V shows the "next screenful", except for one line of overlap to
        !          1148: provide continuity.  To move backward, use ESC V without an argument,
        !          1149: which moves a whole screenful backwards (again with overlap).
        !          1150: .lp
        !          1151: C-Z and ESC Z scroll one line forward and one line backward,
        !          1152: respectively.  These are convenient for moving in units of lines
        !          1153: without having to type a numeric argument.
        !          1154: .lp
        !          1155: Use ESC , to move to the top of the window and ESC .  to go to the
        !          1156: end.  Notice the similarity between ESC , and ESC <, and ESC .  and
        !          1157: ESC >.  The only difference between them is how far they move.
        !          1158: .es
        !          1159: .bs "Multiple Windows"
        !          1160: JOVE allows you to split the screen into two or more \fIwindows\fR and
        !          1161: use them to display parts of different files, or different parts of
        !          1162: the same file.
        !          1163: .ks 1.5i
        !          1164: .dk "C-X 2"
        !          1165: Divide the current window into two smaller ones.
        !          1166: .dk "C-X 1"
        !          1167: Delete windows all but the current one.
        !          1168: .dk "C-X N"
        !          1169: Switch to the next window.
        !          1170: .dk "C-X P"
        !          1171: Switch to the previous window.
        !          1172: .dk "C-X O"
        !          1173: Same as C-X P.
        !          1174: .dk "C-X ^"
        !          1175: Make this window bigger.
        !          1176: .dk "ESC C-V"
        !          1177: Scroll the other window.
        !          1178: .ke
        !          1179: .lp
        !          1180: When using \fImultiple window\fR mode, the text portion of the screen
        !          1181: is divided into separate parts called \fIwindows\fR, which display
        !          1182: different pieces of text.  Each window can display different files, or
        !          1183: parts of the same file.  Only one of the windows is selected; that is
        !          1184: the window which the cursor is in.  Editing normally takes place in
        !          1185: that window alone.  To edit in another window, you would give a
        !          1186: special command to move the cursor to the other window, and then edit
        !          1187: there.
        !          1188: .lp
        !          1189: Each window displays a mode line for the buffer it's displaying.  This
        !          1190: is useful when we are editing different files and want to know which
        !          1191: file the other window is displaying.  In addition, all except the bottom
        !          1192: window put dashes at the beginning and end of the mode line so that
        !          1193: there is a clear seperator between windows.
        !          1194: .lp
        !          1195: The command C-X 2 (split-current-window) enters multiple window mode.
        !          1196: A new mode line appears accross the middle of the screen, dividing the
        !          1197: text display area into two halves.  Both windows contain the same
        !          1198: buffer and display the same position in it, namely where point was at
        !          1199: the time you issued the command.  The cursor moves to the second
        !          1200: window.
        !          1201: .lp
        !          1202: To return to viewing only one window, use the command C-X 1
        !          1203: (delete-other-windows).  The current window expands to fill the whole
        !          1204: screen, and the other windows disappear until the next C-X 2.
        !          1205: .lp
        !          1206: While there is more than one window, you can use C-X N (next-window)
        !          1207: to switch to the next window, and C-X P (previous-window) to switch to
        !          1208: the previous one.  If you are in the bottom window and you type C-X N,
        !          1209: you will be placed in the top window, and the same kind of thing
        !          1210: happens when you type C-X P in the top window, namely you will be
        !          1211: placed in the bottom window.  C-X O is the same as C-X P.  It stands
        !          1212: for other window because when there are only two windows, repeated use
        !          1213: of this command with switch between the two windows.
        !          1214: .lp
        !          1215: Often you will be editing one window while using the other just for
        !          1216: reference.  Then, the command ESC C-V (page-next-window) is very
        !          1217: useful.  It scrolls the next window, as if you switched to the next
        !          1218: window, typed C-V, and switched back, without your having to do all
        !          1219: that.  With a negative argument, ESC C-V will do an ESC V in the next
        !          1220: window.
        !          1221: .lp
        !          1222: When a window splits, both halves are approximately the same size.
        !          1223: You can redistribute the screen space between the windows with the C-X
        !          1224: ^ (grow-window) command.  It makes the currently selected window grow
        !          1225: one line bigger, or as many lines as is specified with a numeric
        !          1226: argument.  Use ESC X shrink-window to make the current window smaller.
        !          1227: .bs Multiple Windows and Mulitple Buffers
        !          1228: Buffers can be selected independently in each window.  The C-X B
        !          1229: command selects a new buffer in whichever window the cursor is in.
        !          1230: The other window's buffer does not change.
        !          1231: .lp
        !          1232: You can view the same buffer in more than one window.  Although the
        !          1233: same buffer appears in both windows, they have different values of
        !          1234: point, so you can move around in one window while the other window
        !          1235: continues to show the same text.  Then, having found the place you
        !          1236: wish to refer to, you can go back into the other window with C-X O to
        !          1237: make your changes.
        !          1238: .lp
        !          1239: If you have the same buffer in both windows, you must beware of trying
        !          1240: to visit a different file in one of the windows with C-X C-V, because
        !          1241: if you bring a new file into this buffer, it will replaced the old
        !          1242: file in \fIboth\fR windows.  To view different files in differnent
        !          1243: windows, you must switch buffers in one of the windows first (with C-X
        !          1244: B or C-X C-F, perhaps).
        !          1245: .lp
        !          1246: A convenient "combination" command for viewing something in another
        !          1247: window is C-X 4 (visit-in-other-window).  With this command you can
        !          1248: ask to see any specified buffer, file or tag in the other window.
        !          1249: Follow the C-X 4 with either B and a buffer name, F and a file name,
        !          1250: or T and a tag name.  This switches to the other window and finds
        !          1251: there what you specified.  If you were previously in one-window mode,
        !          1252: multiple-window mode is entered.  C-X 4 B is similar to C-X 2 C-X B.
        !          1253: C-X 4 F is similar to C-X 2 C-X C-F.  C-X 4 T is similar to C-X 2 C-X
        !          1254: T.  The difference is one of efficiency, and also that C-X 4 works
        !          1255: equally as well if you are already using two windows.
        !          1256: .es
        !          1257: .es
        !          1258: .bs "Replacement Commands"
        !          1259: Global search-and-replace operations are not needed as often in JOVE
        !          1260: as they are in other editors, but they are available.  In addition to
        !          1261: the simple Replace operation which is like that found in most editors,
        !          1262: there is a Query Replace operation which asks you, for each occurrence
        !          1263: of the pattern, whether to replace it.
        !          1264: .lp
        !          1265: To replace every occurrence of FOO after point which BAR, you can do
        !          1266: .eg "ESC R FOO<cr>BAR"
        !          1267: Replacement occurs only after point, so if you want to cover the whole
        !          1268: buffer you must go to the beginning first.  Replacement continues to
        !          1269: the end of the buffer.
        !          1270: .bs "Query Replace"
        !          1271: If you want to change only some of the occurrences of FOO, not all,
        !          1272: then you cannot use and ordinary Replace.  Instead, use
        !          1273: .eg "ESC Q FOO<cr>BAR"
        !          1274: This displays each occurrence of FOO and waits for you to say whether
        !          1275: to replace it with a BAR.  The things you can type when you are shown
        !          1276: an occurrence of FOO are:
        !          1277: .ks 1.3i
        !          1278: .dk "Space"
        !          1279: to replace the FOO.
        !          1280: .dk "Rubout"
        !          1281: to skip the next FOO without replacing this one.
        !          1282: .dk "Return"
        !          1283: to exit without doing any more replacements.
        !          1284: .dk "Period"
        !          1285: to replace this FOO and then exit.
        !          1286: .dk "! or P"
        !          1287: to replace all remaining FOO's without asking.
        !          1288: .dk "C-R or R"
        !          1289: to enter a recursive editing level, in case the FOO needs to be edited
        !          1290: rather than just replaced with a BAR.  When you are done, exit the
        !          1291: recursive editing level with C-X C-C and the next FOO will be
        !          1292: displayed.
        !          1293: .dk "C-W"
        !          1294: to delete the FOO, and then start editing the buffer.  When you are
        !          1295: finished editing whatever is to replace the FOO, exit the recursive
        !          1296: editing level with C-X C-C and the next FOO will be displayed.
        !          1297: .dk "U"
        !          1298: move to the last replacement and undo it, and then enter a recursive
        !          1299: editing level.  When you have finished editing the FOO, exit the
        !          1300: recursive editing level with C-X C-C and then next FOO will be
        !          1301: displayed.
        !          1302: .ke
        !          1303: .es
        !          1304: .es
        !          1305: .bs "Processes Under JOVE"
        !          1306: Another feature in JOVE is its ability to interact with UNIX in a
        !          1307: useful way.  You can run other UNIX commands from JOVE and catch their
        !          1308: output in JOVE buffers.  In this chapter we will discuss the different
        !          1309: ways to run and interact with UNIX commands.
        !          1310: .bs Non-interactive UNIX commands
        !          1311: To run a UNIX command from JOVE just type "C-X !" followed by the name
        !          1312: of the command terminated with Return.  For example, to get a list of
        !          1313: all the users on the system, you do:
        !          1314: .eg "C-X ! who<cr>"
        !          1315: Then JOVE picks a reasonable buffer in which the output from the
        !          1316: command will be placed.  E.g., "who" uses the buffer called "who", and
        !          1317: "ps alx" uses "ps", and "fgrep -n foo *.c" uses "fgrep".  If JOVE
        !          1318: wants to use a buffer that already exists it first erases the old
        !          1319: contents.  If the buffer it selects holds a file, not output from a
        !          1320: previous shell command, you must first delete that buffer with C-X K.
        !          1321: .lp
        !          1322: Once JOVE has picked a buffer it puts that buffer in a window so you
        !          1323: can see the command's output as it is running.  If there is only one
        !          1324: window JOVE will automatically make another one.  Otherwise, JOVE
        !          1325: tries to pick the most convenient one window which isn't the current
        !          1326: one.
        !          1327: .lp
        !          1328: It's not a good idea to type anything while the command is running.
        !          1329: There are two reasons for this:
        !          1330: .ks 1i
        !          1331: .dk "(1)"
        !          1332: JOVE won't see the characters (thus won't execute them) until the
        !          1333: command finishes, so you may forget what you've typed.
        !          1334: .dk "(2)"
        !          1335: Although JOVE won't know what you've typed, it WILL know that you've
        !          1336: typed something, and then it will try to be "smart" and not update the
        !          1337: display until it's interpreted your what you've typed.  But, of
        !          1338: course, JOVE won't interpret what you type until the UNIX command
        !          1339: completes, so you're left with the uneasy feeling you get when you
        !          1340: don't know what the hell the computer is doing.
        !          1341: .fb
        !          1342: This is a bug and should be fixed, but probably won't be for a while.
        !          1343: .fe
        !          1344: .ke
        !          1345: .lp
        !          1346: If you want to interrupt the command for some reason (perhaps you
        !          1347: mistyped it,or you changed your mind) you can type C-].  Typing this
        !          1348: inside JOVE while a process is running is the same as type C-C when
        !          1349: you are outside JOVE, namely the process stops in a hurry.
        !          1350: .lp
        !          1351: When the command finishes JOVE puts you back in the window you started
        !          1352: in.  Then it prints a message indicating whether or not the command
        !          1353: completed successfully in its (the command's) opinion.  That is, if
        !          1354: the command had what it considers and error, JOVE will print an
        !          1355: appropriate message.  Interrupting a command with C-] is considered an
        !          1356: error.
        !          1357: .bs "Limitations of Non-Interactive Processes"
        !          1358: The reason these are called non-interactive processes is that you
        !          1359: can't type any input to them; you can't interact with them; they can't
        !          1360: ask you questions because there is no way for you to answer.  For
        !          1361: example, you can't run a command interpreter (a shell) with C-X !
        !          1362: because there is no way to type it a command.  Remember that JOVE is
        !          1363: listening to your keyboard, not the process in the window, and JOVE
        !          1364: doesn't see what you type until the process dies.
        !          1365: .lp
        !          1366: C-X ! is useful for running commands that do some output and then
        !          1367: exit.  For example, it's very useful to use with the C compiler to
        !          1368: catch compilation error messages (see Compiling C Programs), or with
        !          1369: the "grep" commands.
        !          1370: .es
        !          1371: .es
        !          1372: .bs "Interactive Processes -- Run a Shell in a Window"
        !          1373: Some versions of JOVE have the capability of running interative
        !          1374: processes.  This is more useful than non-interactive processes for
        !          1375: certain types of jobs:
        !          1376: .ks
        !          1377: .dk "(1)"
        !          1378: You can go off and do some editing while the command is running.  This
        !          1379: is useful for commands that do sporadic output and run for fairly long
        !          1380: periods of time.
        !          1381: .dk "(2)"
        !          1382: Unlike non-interactive processes, you can type input to this type.  In
        !          1383: addition, you can edit what you type with the power of all the JOVE
        !          1384: commands \fBbefore\fR you send the input to the process.  This is a
        !          1385: really important feature, and is especially useful for running a shell
        !          1386: in a window.
        !          1387: .dk "(3)"
        !          1388: Because you can continue with normal editing while one of the
        !          1389: processes is running, you can create a bunch of contexts and manage
        !          1390: them (select them, delete them, or temporarily put them aside) with
        !          1391: JOVE's window and buffer mechanisms.
        !          1392: .ke
        !          1393: .lp
        !          1394: Although we've created an image of processes being attached to
        !          1395: windows, in fact they are attached to buffers.  Therefore, once an
        !          1396: i-process is running you can select another buffer into that window,
        !          1397: or if you wish you can delete the window altogether.  If you reselect
        !          1398: that buffer later it will be up to date.  That is, even though the
        !          1399: buffer wasn't visible it was still receiving output from the process.
        !          1400: You don't have to worry about missing anything when the buffer isn't
        !          1401: visible.
        !          1402: .bs Advantages of Running Processes in JOVE Windows.
        !          1403: There are several advantages to running a shell in a window.  What you
        !          1404: type isn't seen immediately by the process ; instead JOVE waits until
        !          1405: you type an entire line before passing it on to the process to read.
        !          1406: This means that before you type Return, all JOVE's editing
        !          1407: capabilities are available for fixing typos on your input line.  If
        !          1408: you discover an error at the beginning of the line, rather than
        !          1409: erasing it and starting over, you can simply move to the error,
        !          1410: correct it, move back and continue typing.
        !          1411: .lp
        !          1412: Another feature is that you have the entire history of your session is
        !          1413: a JOVE buffer.  You don't have to worry about output from a command
        !          1414: moving past the top of the screen.  if you missed some output you can
        !          1415: move back through it with ESC V and other command.  In addition, you
        !          1416: can save yourself retyping a command (or a similar one) by sending
        !          1417: edited versions of previous ones.
        !          1418: .es
        !          1419: .bs "Differences between Normal and I-process Buffers"
        !          1420: JOVE behaves differently in several ways when you are in an I-process
        !          1421: buffer.  The most obvious one is that Return does different things
        !          1422: depending on both your position in the buffer and on the state of the
        !          1423: process.  In the normal case, when point is at the end of the buffer,
        !          1424: Return does what you'd expect: it inserts a line-separator and then
        !          1425: sends the line to the process.  If you are somewhere else in the
        !          1426: buffer, possibly positioned at a previous command that you want to
        !          1427: edit, Return will place a copy of that line (with the prompt discarded
        !          1428: if there is one) at the end of the buffer and move you there.  Then
        !          1429: you can edit the line and type Return as in the normal case.  If the
        !          1430: process has died for some reason, Return does nothing.  It doesn't
        !          1431: even insert itself.  If that happens unexpectedly, you should type ESC
        !          1432: X list-processes<cr> to get a list of each process and its state.  If
        !          1433: your process died abnormally, list-processes may help you figure out
        !          1434: why.
        !          1435: .es
        !          1436: .bs "How to Run a Shell in a Window"
        !          1437: Type ESC X i-shell<cr> to start up a shell.  As with C-X !, JOVE will
        !          1438: create a buffer, called \fBshell.1\fR, and select a window for this
        !          1439: new buffer.  But unlike C-X ! you will be left in the new window.  Now,
        !          1440: the shell process is said to be attached to shell.1, and it is
        !          1441: considered an I-process buffer.
        !          1442: .lp
        !          1443: Needs work.
        !          1444: .es
        !          1445: .es
        !          1446: .es
        !          1447: 
        !          1448: .bs "Editing C Programs"
        !          1449: .bs "Compiling Your Program"
        !          1450: .es
        !          1451: .bs "Indentation Commands"
        !          1452: .es
        !          1453: .bs "Parenthesis and Brace Matching"
        !          1454: .es
        !          1455: .bs "C Tags"
        !          1456: .es
        !          1457: .es
        !          1458: .bs "Error Message Parsing"
        !          1459: .es
        !          1460: .bs "Simple Customization"
        !          1461: .bs "Minor Modes"
        !          1462: .es
        !          1463: .bs "Variables"
        !          1464: .es
        !          1465: .bs "Key Re-binding"
        !          1466: .es
        !          1467: .bs "Keyboard Macros"
        !          1468: .es
        !          1469: .bs "Initialization Files"
        !          1470: .es
        !          1471: .es
        !          1472: .TC
        !          1473: .hy 0

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