Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume1/8707/38

LaTeX Document | 1990-07-13 | 67KB

From: [e-mail] (Jeff Kitson)
Newsgroups: comp.sources.misc
Subject: microemacs documentation in LaTeX (part 2 of 2)
Message-ID: <[e-mail]>
Date: 9 Jul 87 02:59:33 GMT
Sender: [e-mail]
Lines: 1502
Approved: [e-mail]
X-Archive: comp.sources.misc/8707/38
#!/bin/sh
# to extract, remove the header and type "sh filename"
if `test ! -s ./README`
echo "writting ./README"
cat > ./README << '\Rogue\Monster\'
The documentation is provided in three files:
emacs-doc.tex    ;Main LaTeX file that includes part1.tex and part2.tex
    part1.tex    ;first half of documentation
    part2.tex    ;second half of documentation
emacs-doc.toc    ;Table of Contents generated on a previous run of LaTeX
emacs-index.tex  ;Index entries, modified from emacs-doc.idx
The files emacs-doc.tex, part1.tex and part2.tex contain everything
needed to generate the manual for microemacs 3.8i.  The files
emacs-doc.toc and emacs-index.tex are included so that emacs-doc.dvi
can be created in one pass.
sh> latex emacs-doc
There are a couple of LaTeX warnings about underfull boxes, but they
don't make too much of a difference so I left them.
If you want to change the document so that pagebreaks will change
you will need to recreate the emacs-doc.toc and emacs-index.tex files.
The emacs-doc.toc file is created by LaTeX.  The emacs-index.tex file
is a sorted and slightly modified version of emacs-doc.idx (which is
also created by LaTeX).
\Rogue\Monster\
  echo "will not over write ./README"
if [ `wc -c ./README | awk '{printf $1}'` -ne 1019 ]
echo `wc -c ./README | awk '{print "Got " $1 ", Expected " 1019}'`
if `test ! -s ./emacs-doc.tex`
echo "writting ./emacs-doc.tex"
cat > ./emacs-doc.tex << '\Rogue\Monster\'
\documentstyle{book}
\setlength{\textwidth}{6.5in}
\setlength{\textheight}{9in}
\setlength{\topmargin}{0in}
\setlength{\parskip}{10pt plus 2pt minus 2pt}
\setlength{\parindent}{0pt}
\setlength{\oddsidemargin}{0in}
\setlength{\evensidemargin}{0in}
\makeindex
\begin{document}
\include{part1}
\include{part2}
\begin{theindex}
\input{emacs-index.tex}
\end{theindex}
\end{document}
\Rogue\Monster\
  echo "will not over write ./emacs-doc.tex"
if [ `wc -c ./emacs-doc.tex | awk '{printf $1}'` -ne 383 ]
echo `wc -c ./emacs-doc.tex | awk '{print "Got " $1 ", Expected " 383}'`
if `test ! -s ./emacs-doc.toc`
echo "writting ./emacs-doc.toc"
cat > ./emacs-doc.toc << '\Rogue\Monster\'
\contentsline {chapter}{\numberline {1}Basic Concepts}{1}
\contentsline {section}{\numberline {1.1}Keys and the Keyboard}{1}
\contentsline {section}{\numberline {1.2}Getting Started}{1}
\contentsline {section}{\numberline {1.3}Parts and Pieces}{2}
\contentsline {section}{\numberline {1.4}Entering Text}{2}
\contentsline {section}{\numberline {1.5}Basic cursor movement}{3}
\contentsline {section}{\numberline {1.6}Saving your text}{4}
\contentsline {section}{\numberline {1.7}Chapter 1{} Summary}{4}
\contentsline {chapter}{\numberline {2}Basic Editing--Simple Insertions and Deletions}{5}
\contentsline {section}{\numberline {2.1}A Word About Windows, Buffers, Screens, and Modes}{5}
\contentsline {section}{\numberline {2.2}Insertions}{6}
\contentsline {section}{\numberline {2.3}Deletions}{6}
\contentsline {section}{\numberline {2.4}Chapter 2{} Summary}{7}
\contentsline {chapter}{\numberline {3}Using Regions}{9}
\contentsline {section}{\numberline {3.1}Defining and Deleting a Region}{9}
\contentsline {section}{\numberline {3.2}Yanking a Region}{10}
\contentsline {section}{\numberline {3.3}Chapter 3{} Summary}{10}
\contentsline {chapter}{\numberline {4}Search and Replace}{13}
\contentsline {section}{\numberline {4.1}Forward Search}{13}
\contentsline {section}{\numberline {4.2}Exact Searches}{14}
\contentsline {section}{\numberline {4.3}Backward Search}{14}
\contentsline {section}{\numberline {4.4}Searching and Replacing}{14}
\contentsline {section}{\numberline {4.5}Query-Replace-String}{15}
\contentsline {section}{\numberline {4.6}Chapter 4{} Summary}{15}
\contentsline {chapter}{\numberline {5}Windows}{17}
\contentsline {section}{\numberline {5.1}Creating Windows}{17}
\contentsline {section}{\numberline {5.2}Chapter 5{} Summary}{18}
\contentsline {chapter}{\numberline {6}Buffers}{19}
\contentsline {section}{\numberline {6.1}Chapter 6{} Summary}{20}
\contentsline {chapter}{\numberline {7}Modes}{21}
\contentsline {section}{\numberline {7.1}ASAVE mode}{21}
\contentsline {section}{\numberline {7.2}CMODE mode}{21}
\contentsline {section}{\numberline {7.3}CRYPT mode}{22}
\contentsline {section}{\numberline {7.4}EXACT mode}{22}
\contentsline {section}{\numberline {7.5}MAGIC mode}{22}
\contentsline {section}{\numberline {7.6}OVER mode}{23}
\contentsline {section}{\numberline {7.7}WRAP mode}{23}
\contentsline {section}{\numberline {7.8}VIEW mode}{24}
\contentsline {section}{\numberline {7.9}Chapter 7{} Summary}{24}
\contentsline {chapter}{\numberline {8}Files}{25}
\contentsline {section}{\numberline {8.1}Chapter 8{} Summary}{26}
\contentsline {chapter}{\numberline {9}Screen Formatting}{27}
\contentsline {section}{\numberline {9.1}Wrapping Text}{27}
\contentsline {section}{\numberline {9.2}Reformatting Paragraphs}{27}
\contentsline {section}{\numberline {9.3}Changing Case}{27}
\contentsline {section}{\numberline {9.4}Tabs}{28}
\contentsline {section}{\numberline {9.5}Chapter 9{} Summary}{29}
\contentsline {chapter}{\numberline {10}Keyboard Macros}{31}
\contentsline {section}{\numberline {10.1}Chapter 10{} Summary}{31}
\contentsline {chapter}{\numberline {11}MicroEMACS Macros}{33}
\contentsline {section}{\numberline {11.1}Variables}{33}
\contentsline {subsection}{\numberline {11.1.1}Environmental Variables}{34}
\contentsline {subsection}{\numberline {11.1.2}User variables}{34}
\contentsline {subsection}{\numberline {11.1.3}Buffer Variables}{34}
\contentsline {subsection}{\numberline {11.1.4}Interactive variables}{35}
\contentsline {section}{\numberline {11.2}Functions}{35}
\contentsline {section}{\numberline {11.3}Directives}{37}
\contentsline {subsection}{\numberline {11.3.1}!ENDM Directive}{37}
\contentsline {subsection}{\numberline {11.3.2}!FORCE Directive}{38}
\contentsline {subsection}{\numberline {11.3.3}!IF, !ELSE, and !ENDIF Directives}{38}
\contentsline {subsection}{\numberline {11.3.4}!GOTO Directive}{39}
\contentsline {subsection}{\numberline {11.3.5}!RETURN Directive}{39}
\contentsline {chapter}{\numberline {A}MicroEMACS commands}{41}
\contentsline {chapter}{\numberline {B}MicroEMACS Bindings}{45}
\contentsline {chapter}{\numberline {C}Supported machines}{47}
\contentsline {chapter}{\numberline {D}Machine Dependent Notes}{49}
\contentsline {section}{\numberline {D.1}IBM-PC/XT/AT and its clones}{49}
\contentsline {section}{\numberline {D.2}Atari 520/1040ST}{50}
\contentsline {section}{\numberline {D.3}Amiga 1000}{51}
\contentsline {section}{\numberline {D.4}UNIX V5, V7, and BSD4.[23]}{51}
\Rogue\Monster\
  echo "will not over write ./emacs-doc.toc"
if [ `wc -c ./emacs-doc.toc | awk '{printf $1}'` -ne 4464 ]
echo `wc -c ./emacs-doc.toc | awk '{print "Got " $1 ", Expected " 4464}'`
if `test ! -s ./emacs-index.tex`
echo "writting ./emacs-index.tex"
cat > ./emacs-index.tex << '\Rogue\Monster\'
\item $<${}NL$>${},\hspace{.6em} 1, 13
\item add-global-mode,\hspace{.6em} 21
\item add-mode,\hspace{.6em} 3, 21
\item backward-character,\hspace{.6em} 3
\item begin-macro,\hspace{.6em} 31
\item beginning-of-file,\hspace{.6em} 3, 6
\item beginning-of-line,\hspace{.6em} 3
\item buffer,\hspace{.6em} 4, 5, 19
\item case-region-lower,\hspace{.6em} 28
\item case-word-capitalize,\hspace{.6em} 28
\item case-word-lower,\hspace{.6em} 28
\item case-word-upper,\hspace{.6em} 28
\item change-screen-size,\hspace{.6em} 51
\item change-screen-width,\hspace{.6em} 51
\item color,\hspace{.6em} 21
\item control key,\hspace{.6em} 1
\item control-x,\hspace{.6em} 1
\item copy-region,\hspace{.6em} 10
\item cursor keys,\hspace{.6em} 4
\item default string,\hspace{.6em} 14
\item delete-blank-lines,\hspace{.6em} 7
\item delete-buffer,\hspace{.6em} 20
\item delete-global-mode,\hspace{.6em} 21
\item delete-mode,\hspace{.6em} 21
\item delete-next-character,\hspace{.6em} 6
\item delete-next-word,\hspace{.6em} 6
\item delete-previous-character,\hspace{.6em} 6
\item delete-previous-word,\hspace{.6em} 6
\item detab-line,\hspace{.6em} 29
\item encryption,\hspace{.6em} 22
\item end-macro,\hspace{.6em} 31
\item end-of-file,\hspace{.6em} 3
\item end-of-line,\hspace{.6em} 3
\item entab-lines,\hspace{.6em} 29
\item execute-buffer,\hspace{.6em} 33
\item execute-file,\hspace{.6em} 33
\item execute-macro-$<${}n$>${},\hspace{.6em} 33
\item execute-macro,\hspace{.6em} 31
\item exit-emacs,\hspace{.6em} 7
\item file locking,\hspace{.6em} 51
\item fill column,\hspace{.6em} 23
\item fill-paragraph,\hspace{.6em} 6, 27
\item find-file,\hspace{.6em} 17, 19
\item forward-character,\hspace{.6em} 3
\item handle-tab,\hspace{.6em} 29
\item kill buffer,\hspace{.6em} 10
\item kill-region,\hspace{.6em} 9
\item kill-to-end-of-line,\hspace{.6em} 7
\item list-buffers,\hspace{.6em} 19, 21
\item mark,\hspace{.6em} 9
\item meta key,\hspace{.6em} 1
\item mode line,\hspace{.6em} 2, 5
\item modes,\hspace{.6em} 3, 21
\item move-window-down,\hspace{.6em} 18
\item move-window-up,\hspace{.6em} 18
\item next-buffer,\hspace{.6em} 19
\item next-line,\hspace{.6em} 3
\item next-paragraph,\hspace{.6em} 3
\item open-line,\hspace{.6em} 6
\item point,\hspace{.6em} 9
\item previous-line,\hspace{.6em} 3
\item previous-paragraph,\hspace{.6em} 3
\item previous-window,\hspace{.6em} 17
\item previous-word,\hspace{.6em} 3
\item query-replace-string,\hspace{.6em} 15
\item replace-string,\hspace{.6em} 14
\item save-file,\hspace{.6em} 4
\item screen,\hspace{.6em} 5
\item scroll-next-down,\hspace{.6em} 18
\item scroll-next-up,\hspace{.6em} 18
\item search-forward,\hspace{.6em} 13
\item search-reverse,\hspace{.6em} 14
\item select-buffer,\hspace{.6em} 19
\item set-encryption-key,\hspace{.6em} 22
\item set-fill-column,\hspace{.6em} 27
\item set-mark,\hspace{.6em} 9
\item special keys,\hspace{.6em} 1
\item split-current-window,\hspace{.6em} 17
\item suspend-emacs,\hspace{.6em} 51
\item tab handling,\hspace{.6em} 29
\item termcap,\hspace{.6em} 51
\item text window,\hspace{.6em} 2
\item window,\hspace{.6em} 2, 5, 17
\item wrap-word,\hspace{.6em} 24
\item wrapping text,\hspace{.6em} 27
\item write-file,\hspace{.6em} 4
\item yank,\hspace{.6em} 10
\Rogue\Monster\
  echo "will not over write ./emacs-index.tex"
if [ `wc -c ./emacs-index.tex | awk '{printf $1}'` -ne 3207 ]
echo `wc -c ./emacs-index.tex | awk '{print "Got " $1 ", Expected " 3207}'`
if `test ! -s ./part1.tex`
echo "writting ./part1.tex"
cat > ./part1.tex << '\Rogue\Monster\'
\thispagestyle{empty}
\hbox{}
\vfill
\centerline{{\Large\bf{}MicroEMACS}}
\vspace{.25in}
\centerline{Full Screen Text Editor}
\centerline{Reference Manual (preliminary draft)}
\vspace{.5in}
\centerline{Version 3.8i}
\centerline{April 27, 1987}
\vspace{1in}
\centerline{\copyright 1987 by Daniel M. Lawrence}
\centerline{Reference Manual \copyright 1987 by Brian Straight and
Daniel M. Lawrence}
\centerline{All Rights Reserved}
\vspace{.5in}
{\it{}MicroEMACS 3.8i can be copied and distributed freely
for any non-commercial purposes. MicroEMACS 3.8i can
only be incorporated into commercial software with
the permission of the current author.}
\vfill
\newpage
\pagenumbering{roman}
\setcounter{page}{1}
\tableofcontents
\cleardoublepage
\chapter*{Introduction}
MicroEMACS is a tool for creating and changing documents,
programs, and other text files.  It is both relatively easy for the
novice to use, but also very powerfull in the hands of an expert.
MicroEMACS can be extensively customized for the needs of the
individual user.
MicroEMACS allows several files to be edited at the same time.
The screen can be split into different windows, and text may be moved
freely from one window to the next.  Depending on the type of file being
edited, MicroEMACS can change how it behaves to make editing simple.
Editing standard text files, program files and wordprocessing documents
are all possible at the same time.
There are extensive capabilities to make word processing and
editing easier.  These include commands for string searching and
replacing, paragraph reformatting and deleting, automatic word wrapping,
word move and deletes, easy case controling, and automatic word counts.
For complex and repetitive editing tasks editing macroes can be
written.  These macroes allow the user a great degree of flexibility in
determining how MicroEMACS behaves.  Also any and all the commands can
be used by any keystroke by changing, or rebinding, what commands
various keys are connected, or bound, to.
Special features are also available to perform a diverse set of
operations such as file encryption, automatic backup file generation,
entabbing and detabbing lines, executing of DOS commands and filtering
of text through other programs (like SORT to allow sorting text).
\chapter*{History}
EMACS was originally a text editor written by Richard Stallman
at MIT in the early 1970s for Digital Equipment computers. Various
versions, rewrites and clones have made an appearence since.
This version of MicroEMACS is derived from code written by Dave
G.  Conroy in 1985.  Later modifications were performed by Steve Wilhite
and George Jones.  In December of 1985 Daniel Lawrence picked up the
then current source (version 2.0) and has made extensive modifications
and additions to it over the course of the next two years.  Updates and
support for the current version is still in progress.  The current
program author can be contacted by writing to:
\begin{verbatim}
        USMAIL: Daniel Lawrence
                617 New York St
                Lafayette, IN 47901
          UUCP: ihnp4!pur-ee!pur-phy!duncan!lawrence
          ARPA: [e-mail]
          FIDO: Fido 201/2 The Programmer's Room [phone]
\end{verbatim}
\chapter{Basic Concepts}
\pagenumbering{arabic}
The current version of MicroEMACS is 3.8i (Third major re-write,
eighth public release, Ith (or ninth) minor release), and for the rest of
this document, we shall simply refer to this version as ``EMACS".  Any
modifications for later versions will be listed in the appendixes at the
end of this manual.
\section{Keys and the Keyboard}
Many times throught this manual we will be talking about
\index{special keys} commands and the keys on the keyboard needed use
them.  There are a number of ``special" keys which can be used and are
listed here:
\begin{description}
\item[$<${}NL$>${}] NewLine which is also called RETURN or ENTER,
this key is used to \index{$<${}NL$>${}} end different commands.
\item[\^{}] The control key can be used before any alphabetic
character and some symbols.  For example, \^{}C means to hold down the
$<${}CONTROL$>${} key and type \index{control key} the C key at the
same time.
\item[\^{}X] The CONTROL-X key is used at the beginning of many different
\index{control-x} commands.
\item[META or M-] This is a special EMACS key used to begin many
commands as \index{meta key} well.  This key is pressed, and then
released before typing the next character.  On most systems, this is
the $<${}ESC$>${} key, but it can be changed.  (consult appendix D to
learn what key is used for META on your computer).  \end{description}
Whenever a command is described, the manual will list the actual
keystokes needed to execute it in {\bf{}boldface} using the above
conventions, and also the name of the command in {\it{}italics}.
\section{Getting Started}
In order to use EMACS, you must call it up from your system's or
computer's command prompt.  On UNIX and MSDOS machines, just type
``emacs" from the main command prompt and follow it with the
$<${}RETURN$>${} or $<${}ENTER$>${} key (we will refer to this key as
$<${}NL$>${} for ``new-line" for the remainder of this manual).  On
the Macintosh, the Amiga, the ATARI ST and other icon based operating
systems, double click on the uEMACS icon.  Shortly after this, a
screen similar to the one below should appear.
\section{Parts and Pieces}
The screen is divided into a number of areas or {\bf{}windows}.  On
some systems the top window contains a function list of unshifted and
\index{window} shifted function keys.  We will discuss these keys later.
\index{mode line} Below them is an EMACS {\bf{}mode line} which, as we will
see, informs you of the present mode of operation of the editor--for
example ``(WRAP)" if you set EMACS to wrap at the end of each line.
\index{text window} Under the mode line is the {\bf{}text window} where text
appears and is manipulated.  Since each window has its own mode line,
below the text window is it's mode line.  The last line of the screen is
the {\bf{}command line} where EMACS takes commands and reports on what it
is doing.
\begin{verbatim}
===============================================================================
f1 search      f2 search back : F1 toggle function list F2 toggle help file
f3 hunt        f4 hunt back   : F3 find command/apropos F4 describe key
f5 next window f6 exec macro  : F5 reformat paragraph   F6 ref undented region
f7 find file   f8 exec file   : F7 indent region        F8 undent region
f9 save file  f10 exit emacs  : F9 execute DOS command F10 shell up
===============================================================================
-- MicroEMACS 3.8i () -- Function Keys ---------------------------------------
===============================================================================
===============================================================================
-- MicroEMACS 3.8i () -- Main ------------------------------------------------
===============================================================================
                    Fig 1:  EMACS screen on an IBM-PC
\end{verbatim}
\section{Entering Text}
Entering text in EMACS is simple.  Type the following sentence fragment:
\begin{verbatim}
        Fang Rock lighthouse, center of a series of mysterious and
\end{verbatim}
The text is displayed at the top of the text window.  Now type:
\begin{verbatim}
        terrifying events at the turn of the century
\end{verbatim}
Notice the text to the left of the cursor disappears and a `\$' sign
appears.  Don't panic--your text is safe!!! You've just discovered
that EMACS doesn't ``wrap" text to the next line like most word
processors unless you hit $<${}NL$>${}.  But since EMACS is used for
both word processing, and text editing, it has a bit of a dual
personality.  You can change \index{modes} the way it works by setting
various {\bf{}modes}.  In this case, you need to set {\bf{}WRAP} mode,
using the {\it{}add-mode} \index{add-mode} command, by typing
{\bf{}\^{}X-M}.  The command line at the base of the screen will
prompt you for the mode you wish to add.  Type {\bf{}wrap} followed by
the $<${}NL$>${} key and any text you now enter will be wrapped.
However, the command doesn't wrap text already entered.  To get rid of
the truncated line, delete characters with the $<${}BACKSPACE$>${} key
until the `\$' goes away.  Now type in the words you deleted, watch
how EMACS goes down to the next line at the right time.  {\it{}(In
some versions of EMACS, {\bf{}WRAP} is a default mode in which case
you don't have to worry about the instructions relating to adding this
mode.)}
Now let's type a longer insert.  Hit $<${}NL$>${} a couple of times to tab
down from the text you just entered.  Now type the following paragraphs.
Press $<${}NL$>${} twice to indicate a paragraph break.
\begin{verbatim}
        Fang Rock lighthouse, center of a series of mysterious and
        terrifying events at the turn of the century, is built on a
        rocky island a few miles of the Channel coast.  So small is
        the island that wherever you stand its rocks are wet with sea
        spray.
        The lighthouse tower is in the center of the island.  A steep
        flight of steps leads to the heavy door in its base.  Winding
        stairs lead up to the crew room.
\end{verbatim}
\section{Basic cursor movement}
Now let's practice moving around in this text.  To move the cursor
back to the word ``Winding," enter {\bf{}M-B} {\it{}previous-word}
\index{previous-word}.  This command moves the cursor backwards by one
word at a time.  Note you have to press the key combination every time
the cursor steps back by one word.  Continuously pressing META and
toggling B produces an error message.  To move forward to the word
``stairs" enter {\bf{}M-F} {\it{}next-word}, which moves the cursor
forward by one word at a time.
Notice that EMACS commands are usually mnemonic--F for forward, B for
backward, for example.
To move the cursor up one line, enter {\bf{}\^{}P} {\it{}previous-line}
\index{previous-line}, down one line {\bf{}\^{}N} {\it{}next-line}
\index{next-line}.  Practice this movement by moving the cursor to the
word ``terrifying" in the second line.
The cursor may also be moved forward or backward in smaller
increments.  To move forward by one character, enter {\bf{}\^{}F}
{\it{}forward-character} \index{forward-character}, to move backward,
{\bf{}\^{}B} {\it{}backward-character} \index{backward-character}.
EMACS also allows you to specify a number which is normally used to
tell a command to execute many times.  To repeat most commands, press
META and then the number before you enter the command.  Thus, the
command META 5 \^{}F ({\bf{}M-5\^{}F}) will move the cursor forward by
five characters.  Try moving around in the text by using these
commands.  For extra practice, see how close you can come to the word
``small" in the first paragraph by giving an argument to the commands
listed here.
Two other simple cursor commands that are useful to help us move
around in the text are {\bf{}M-N} {\it{}next-paragraph}
\index{next-paragraph} which moves the cursor to the second paragraph,
and {\bf{}M-P} {\it{}previous-paragraph} \index{previous-paragraph}
which moves it back to the previous paragraph.  The cursor may also be
moved rapidly from one end of the line to the other.  Move the cursor
to the word ``few" in the second line.  Press {\bf{}\^{}A}
{\it{}beginning-of-line} \index{beginning-of-line}.  Notice the cursor
moves to the word ``events" at the beginning of the line.  Pressing
{\bf{}\^{}E} {\it{}end-of-line} \index{end-of-line} moves the cursor
to the end of the line.
Finally, the cursor may be moved from any point in the file to the end
or beginning of the file.  Entering {\bf{}M-$>${}} {\it{}end-of-file}
\index{end-of-file} moves the cursor to the end of the buffer,
{\bf{}M-$<${}} {\it{}beginning-of-file} \index{beginning-of-file} to
the first character of the file.
{\it{}On the IBM-PC, the ATARI ST and many other machines, the cursor keys
\index{cursor keys} can also be used to move the cursor about.  Also, if
there is one available, moving the mouse will move the cursor.}
Practice moving the cursor in the text until you are comfortable with
the commands we've explored in this chapter.
\section{Saving your text}
When you've finished practicing cursor movement, save your file.  Your
\index{buffer} file currently resides in a {\bf{}BUFFER}.  The buffer
is a temporary storage area for your text, and is lost when the
computer is turned off.  You can save the buffer to a file by entering
{\bf{}\^{}X-\^{}S} {\it{}save-file} \index{save-file}.  Notice that
EMACS informs you that your file has no name and will not let you save
To save your buffer to a file with a different name than it's current
one (which is empty), press {\bf{}\^{}X-\^{}W} {\it{}write-file}
\index{write-file}.  EMACS will prompt you for the filename you wish
to write.  Enter the name {\bf{}fang.txt} and press return.  On a
micro, the drive light will come on, and EMACS will inform you it is
writing the file.  When it finishes, it will inform you of the number
of lines it has written to the disk.
Congratulations!! You've just saved your first EMACS file!
%\newpage
\section{Chapter \thechapter{} Summary}
In chapter \thechapter{}, you learned how to enter text, how
to use wrap mode, how to move the cursor, and to save a buffer.  The
following is a table of the commands covered in this chapter and their
corresponding key bindings:
\begin{tabular}{llp{4in}}
Key Binding & Keystroke & Effect \\ \hline
abort-command & {\bf{}\^{}G} & aborts current command \\
add-mode & {\bf{}\^{}X-M} & allows addition of EMACS
mode such as {\bf{}WRAP}\\
backward-character & {\bf{}\^{}B} & moves cursor left one character\\
beginning-of-file & {\bf{}M-$<${}} & moves cursor to beginning of file\\
beginning-of-line & {\bf{}\^{}A} & moves cursor to beginning of line\\
end-of-file & {\bf{}M-$>${}} & moves cursor to end of file\\
end-of-line & {\bf{}\^{}E} & moves cursor to end of line\\
forward-character & {\bf{}\^{}F} & moves cursor right one character\\
next-line & {\bf{}\^{}N} & moves cursor to next line\\
next-paragraph & {\bf{}M-N} & moves cursor to next paragraph\\
next-word & {\bf{}M-F} & moves cursor forward one word\\
previous-line & {\bf{}\^{}P} & moves cursor backward by one line\\
previous-paragraph & {\bf{}M-P} & moves cursor to previous paragraph\\
previous-word & {\bf{}M-B} & moves cursor backward by one word\\
save-file & {\bf{}\^{}X-\^{}S} & saves current buffer to a file\\
write-file & {\bf{}\^{}X-\^{}W} & save current buffer under a new name\\
\end{tabular}
%\newpage
\chapter{Basic Editing--Simple Insertions and Deletions}
\section{A Word About Windows, Buffers, Screens, and Modes}
In the first chapter, you learned how to create and save a file in
EMACS.  Let's do some more editing on this file.  Call up emacs by
typing in the following command.
\begin{verbatim}
        emacs fang.txt
\end{verbatim}
{\it{}On icon oriented systems, double click on the uEMACS icon, usually a
file dialog box of some sort will appear.  Choose {\bf{}FANG.TXT} from the
appropriate folder.}
Shortly after you invoke EMACS, the text should appear on the screen
ready for you to edit.  The text you are looking at currently resides in
a {\bf{}buffer}.  A buffer is a temporary area of computer memory which is
\index{buffer} the primary unit internal to EMACS -- this is the place
where EMACS goes to work.  The mode line at the bottom of the screen
lists the buffer name, {\bf{}FANG.TXT} and the name of the file with which
this buffer is associated, {\bf{}FANG.TXT}
The computer talks to you through the use of its {\bf{}screen}.  This
\index{screen} screen usually has an area of 24 lines each of 80
characters across.  You can use EMACS to subdivide the screen into
several separate work areas, or {\bf{}windows}, each of which can be
\index{window} `looking into' different files or sections of text.  Using
windows, you can work on several related texts at one time, copying and
moving blocks of text between windows with ease.  To keep track of what
you are editing, each window is identified by a {\bf{}mode line} on the
\index{mode line} \index{buffer} last line of the window which lists the
name of the {\bf{}buffer} which it is looking into, the file from which the
text was read, and how the text is being edited.
An EMACS {\bf{}mode} tells EMACS how to deal with user input.  As we have
already seen, the mode `WRAP' controls how EMACS deals with long lines
(lines with over 79 characters) while the user is typing them in.  The
`VIEW' mode, allows you to read a file without modifying it.  Modes are
associated with buffers and not with files; hence, a mode needs to be
explicitly set or removed every time you edit a file.  A new file read
into a buffer with a previously specified mode will be edited under this
mode.  If you use specific modes frequently, EMACS allows you to set
the modes which are used by all new buffers, called {\bf{}global} modes.
\section{Insertions}
Your previously-saved text should look like this:
\begin{verbatim}
        Fang Rock lighthouse, center of a series of mysterious and
        terrifying events at the turn of the century, is built on a
        rocky island a few miles of the Channel coast.  So small is
        the island that wherever you stand its rocks are wet with sea
        spray.
        The lighthouse tower is in the center of the island.  A steep
        flight of steps leads to the heavy door in its base.  Winding
        stairs lead up to the crew room.
\end{verbatim}
Let's assume you want to add a sentence in the second paragraph after
the word ``base."  Move the cursor until it is on the ``W" of ``Winding".
Now type the following:
\begin{verbatim}
        This gives entry to the lower floor where the big steam
        generator throbs steadily away, providing power for the
        electric lantern.
\end{verbatim}
If the line fails to wrap and you end up with a `\$' sign in the right
margin, just enter {\bf{}M-Q} {\it{}fill-paragraph}
\index{fill-paragraph} to reformat the paragraph.  This new command
attempts to fill out a paragraph.  Long lines are divided up, and
words are shuffled around to make the paragraph look nicer.
Notice that all visible EMACS characters are self-inserting -- all you
had to do was type the characters to insert and the exisiting text
made space for it.  With a few exceptions discussed later, all
non-printing characters (such as control or escape sequences) are
commands.  To insert spaces, simply use the space bar.  Now move to
the first line of the file and type {\bf{}\^{}O} {\it{}open-line}
\index{open-line} (Oh, not zero).  You've just learned how to insert a
blank line in your text.
\section{Deletions}
EMACS offers a number of deletion options.  For example, move the cursor
until it's under the period at the end of the insertion you just did.
Press the backspace key.  Notice the ``n" on ``lantern" disappeared.  The
backspace implemented on EMACS is called a {\bf{}destructive} backspace--it
removes text immediately before the current cursor position from the
buffer.  Now type {\bf{}\^{}H} {\it{}delete-previous-character}
\index{delete-previous-character}.  Notice that the cursor moves back
and obliterates the ``r"--either command will backspace the cursor.
Type in the two letters you erased to restore your text and move the
cursor to the beginning of the buffer {\bf{}M-$<${}}
{\it{}beginning-of-file} \index{beginning-of-file}.  Move the cursor
down one line to the beginning of the first paragraph.
To delete the forward character, type {\bf{}\^{}D}
{\it{}delete-next-character} \index{delete-next-character}.  The ``F"
of ``Fang" disappears.  Continue to type {\bf{}\^{}D} until the whole
word is erased EMACS also permits the deletion of larger elements of
text.  Move the cursor to the word ``center" in the first line of
text.  Pressing {\bf{}M-$<${}backspace$>${}}
{\it{}delete-previous-word} \index{delete-previous-word} kills the
word immediately before the cursor.  {\bf{}M-\^{}H} has the same
effect.
Notice that the commands are very similar to the control commands you
used to delete individual letters.  As a general rule in EMACS,
control sequences affect small areas of text, META sequences larger
areas.  The word forward of the cursor position can therefore be
deleted by typing {\bf{}M-D} {\it{}delete-next-word}
\index{delete-next-word}.  Now let's take out the remainder of the
first line by typing {\bf{}\^{}K} {\it{}kill-to-end-of-line}
\index{kill-to-end-of-line}.  You now have a blank line at the top of
your screen.  Typing {\bf{}\^{}K} again or {\bf{}\^{}X-\^{}O}
{\it{}delete-blank-lines} \index{delete-blank-lines} deletes the blank
line and flushes the second line to the top of the text.  Now exit
EMACS by typing {\bf{}\^{}X-\^{}C} {\it{}exit-emacs}
\index{exit-emacs}.  Notice EMACS reminds you that you have not saved
your buffer.  Ignore the warning and exit.  This way you can exit
EMACS without saving any of the changes you just made.
\section{Chapter \thechapter{} Summary}
In Chapter \thechapter{}, you learned about the basic `building
blocks' of an EMACS text file--buffers, windows, and files.
\begin{tabular}{llp{271pt}}
Key binding & Keystroke & Effect\\ \hline
delete-previous-character & {\bf{}\^{}H} & deletes character
immediately before the current cursor position\\
delete-next-character & {\bf{}\^{}D} & deletes character immediately
after current cursor position\\
delete-previous-word & {\bf{}M-\^{}H} & deletes word immediately before
current cursor position\\
delete-next-word & {\bf{}M-D} & deletes word immediately after
current cursor position\\
kill-to-end-of-line & {\bf{}\^{}K} & deletes from current cursor
position to end of line\\
insert-space & {\bf{}\^{}C} & inserts a space to right of cursor\\
open-line & {\bf{}\^{}O} & inserts blank line\\
delete-blank-lines & {\bf{}\^{}X-\^{}O} & removes blank line\\
exit-emacs & {\bf{}\^{}X-\^{}C} & exits emacs\\
\end{tabular}
\chapter{Using Regions}
\section{Defining and Deleting a Region}
At this point its time to familiarize ourselves with two more EMACS
terms--the {\bf{}point} and the {\bf{}mark}.  The point is located directly
\index{point} \index{mark} behind the current cursor position.  The mark
(as we shall see shortly) is user defined.  These two elements together
are called the current {\bf{}region} and limit the {\bf{}region} of text on
which EMACS performs many of its editing functions.
Let's begin by entering some new text.  Don't forget to add {\bf{}wrap}
mode if it's not set on this buffer.  Start EMACS and open a file called
{\bf{}PUBLISH.TXT}.  Type in the following text:
\begin{verbatim}
        One of the largest growth areas in personal computing is
        electronic publishing.  There are packages available for
        practically every machine from elegantly simple programs for
        the humble Commodore 64 to sophisticated professional packages
        for PC and Macintosh computers.
        Electronic publishing is as revolutionary in its way as the
        Gutenburg press.  Whereas the printing press allowed the mass
        production and distribution of the written word, electronic
        publishing puts the means of production in the hands of nearly
        every individual.  From the class magazine to the corporate
        report, electronic publishing is changing the way we produce
        and disseminate information.
        Personal publishing greatly increases the utility of
        practically every computer.  Thousands of people who joined
        the computer revolution of this decade only to hide their
        machines unused in closets have discovered a new use for them
        as dedicated publishing workstations.
\end{verbatim}
Now let's do some editing.  The last paragraph seems a little out of
place.  To see what the document looks like without it we can cut it
from the text by moving the cursor to the beginning of the paragraph.
Enter {\bf{}M-$<${}space$\>${}} {\it{}set-mark} \index{set-mark}.
EMACS will respond with ``[Mark set]".  Now move the cursor to the end
of the paragraph.  You have just defined a region of text.  To remove
this text from the screen, type {\bf{}\^{}W} {\it{}kill-region}
\index{kill-region}.  The paragraph disappears from the screen.
On further consideration, however, perhaps the paragraph we cut wasn't
so bad after all.  The problem may have been one of placement.  If we
could tack it on to the end of the first paragraph it might work quite
well to support and strengthen the argument.  Move the cursor to the
end of the first paragraph and enter {\bf{}\^{}Y} {\it{}yank}
\index{yank}.  Your text should now look like this (use {\bf{}M-Q} to
reformat):
\begin{verbatim}
        One of the largest growth areas in personal computing is
        electronic publishing.  There are packages available for
        practically every machine from elegantly simple programs for
        the humble Commodore 64 to sophisticated professional packages
        for PC and Macintosh computers.  Personal publishing greatly
        increases the utility of practically every computer.
        Thousands of people who joined the computer revolution of this
        decade only to hide their machines unused in closets have
        discovered a new use for them as dedicated publishing
        workstations.
        Electronic publishing is as revolutionary in its way as the
        Gutenburg press.  Whereas the printing press allowed the mass
        production and distribution of the written word, electronic
        publishing puts the means of production in the hands of nearly
        every individual.  From the class magazine to the corporate
        report, electronic publishing is changing the way we produce
        and disseminate information.
\end{verbatim}
\section{Yanking a Region}
The text you cut initially didn't simply just disappear, it was cut
into a buffer that retains the `killed' text appropriately called the
{\bf{}kill buffer}.  {\bf{}\^{}Y} ``yanks" the text back from this
buffer into the current buffer. If you have a long line (indicated,
remember, by the ``\$" sign), simply hit {\bf{}M-Q} to reformat the
paragraph.
There are other uses to which the kill buffer can be put.  Using the
\index{kill buffer} method we've already learned, define the last
paragraph as a region.  Now type {\bf{}M-W} {\it{}copy-region}
\index{copy-region}.  Nothing seems to have happened; the cursor stays
blinking at the point.  But things have changed, even though you may not
be able to see any alteration.
To see what has happened to the contents of the kill buffer, move the
cursor down a couple of lines and ``yank" the contents of the kill buffer
back with {\bf{}\^{}Y}.  Notice the last paragraph is now repeated.  The
region you defined is ``tacked on" to the end of your file because
{\bf{}M-W} {\bf{}copies} a region to the kill buffer while leaving the
original text in your working buffer.  Some caution is needed however,
because the contents of the kill buffer are updated when you delete any
regions, lines or words.  If you are moving large quantities of text,
complete the operation before you do any more deletions or you could
find that the text you want to move has been replaced by the most recent
deletion.  Remember--a buffer is a temporary area of computer memory
that is lost when the machine is powered down or switched off.  In order
to make your changes permanent, they must be saved to a file before you
leave EMACS.  Let's delete the section of text we just added and save
the file to disk.
\section{Chapter \thechapter{} Summary}
In Chapter \thechapter{}, you learned how to achieve longer insertions
and deletions.  The EMACS terms {\bf{}point} and {\bf{}mark} were introduced
and you learned how to manipulate text with the kill buffer.
\begin{tabular}{llp{4in}}
Key Binding & Keystroke & Effect \\ \hline
Delete-Region & {\bf{}\^{}W} & Deletes region between point and mark
and places it in KILL buffer \\
Copy-Region & {\bf{}M-W} & Copies text between point and mark into
KILL buffer \\
Yank-Text & {\bf{}\^{}Y} & Inserts a copy of the KILL buffer into
current buffer at point \\
\end{tabular}
\chapter{Search and Replace}
\section{Forward Search}
Load EMACS and bring in the file you just saved.  Your file should look
like the one below.
\begin{verbatim}
        One of the largest growth areas in personal computing is
        electronic publishing.  There are packages available for
        practically every machine from elegantly simple programs for
        the humble Commodore 64 to sophisticated professional packages
        for PC and Macintosh computers.  Personal publishing greatly
        increases the utility of practically every computer.
        Thousands of people who joined the computer revolution of this
        decade only to hide their machines unused in closets have
        discovered a new use for them as dedicated publishing
        workstations.
        Electronic publishing is as revolutionary in its way as the
        Gutenburg press.  Whereas the printing press allowed the mass
        production and distribution of the written word, electronic
        publishing puts the means of production in the hands of nearly
        every individual.  From the class magazine to the corporate
        report, electronic publishing is changing the way we produce
        and disseminate information.
\end{verbatim}
Let's use EMACS to search for the word ``revolutionary" in the second
paragraph.  Because EMACS searches from the current cursor position
toward the end of buffers, and we intend to search forward, move the
cursor to the beginning of the text.  Enter {\bf{}\^{}S}
{\it{}search-forward} \index{search-forward}.  Note that the command
line now reads
\begin{verbatim}
        Search [] <META>:
\end{verbatim}
EMACS is prompting you to enter the {\bf{}search string} -- the text you
want to find.  Enter the word {\bf{}revolutionary} and hit the {\bf{}META}
key.  The cursor moves to the end of the word ``revolutionary."
Notice that you must enter the $<${}META$>${} key to start the search.
If you \index{$<${}NL$>${}} simply press $<${}NL$>${} the command line
responds with ``$<${}NL$>${}".  Although this may seem infuriating to
users who are used to pressing the return key to execute any command,
EMACS' use of $<${}META$>${} to begin searches allows it to pinpoint
text with great accuracy.  After every line wrap or carriage return,
EMACS `sees' a new line character ($<${}NL$>${}).  If you need to
search for a word at the end of a line, you can specify this word
uniquely in EMACS.
In our sample text for example, the word ``and" occurs a number of
times, but only once at the end of a line.  To search for this
particular occurance of the word, move the cursor to the beginning of
the buffer and type {\bf{}\^{}S}.  Notice that EMACS stores the last
specified \index{default string} search string as the {\bf{}default}
string.  If you press {\bf{}$<${}META$>${}} now, EMACS will search for
the default string, in this case, ``revolutionary."
To change this string so we can search for our specified ``and" simply
enter the word {\bf{}and} followed by {\bf{}$<${}NL$>${}}.  The command
line now shows:
\begin{verbatim}
        Search [and<NL>]<META>:
\end{verbatim}
Press {\bf{}$<${}META$>${}} and the cursor moves to ``and" at the end
of the second last line.
\section{Exact Searches}
If the mode EXACT is active in the current buffer, EMACS searches on a case
sensitive basis.  Thus, for example you could search for {\bf{}Publishing}
as distinct from {\bf{}publishing}.
\section{Backward Search}
Backward searching is very similar to forward searching except that it
is implemented in the reverse direction.  To implement a reverse
search, type {\bf{}\^{}R} {\it{}search-reverse}
\index{search-reverse}.  Because EMACS makes no distinction between
forward and backward stored search strings, the last search item you
entered appears as the default string.  Try searching back for any
word that lies between the cursor and the beginning of the buffer.
Notice that when the item is found, the point moves to the beginning
of the found string (i.e., the cursor appears under the first letter
of the search item).
Practice searching for other words in your text.
\section{Searching and Replacing}
Searching and replacing is a powerful and quick way of making changes
to your text.  Our sample text is about electronic publishing, but the
correct term is `desktop' publishing.  To make the necessary changes
we need to replace all occurances of the word ``electronic" with
``desktop."  First, move the cursor to the top of the current buffer
with the {\bf{}M-$<${}} command.  Then type {\bf{}M-R}
{\it{}replace-string} \index{replace-string}.  The command line
responds:
\begin{verbatim}
        Replace []<META>:
\end{verbatim}
where the square brackets enclose the default string.  Type the word
{\bf{}electronic} and hit {\bf{}$<${}META$>${}}.  The command line responds:
\begin{verbatim}
        with []<META>
\end{verbatim}
type {\bf{}desktop$<${}META$>${}}.  EMACS replaces all instances of
the original word with your revision.  Of course, you will have to
captialize the first letter of ``desktop" where it occurs at the
beginning of a sentence.
You have just completed an {\bf{}unconditional replace}.  In this
operation, EMACS replaces every instance of the found string with the
replacement string.
\section{Query-Replace-String}
You may also replace text on a case by case basis.  The {\bf{}M-\^{}R}
{\it{}query-replace-string} \index{query-replace-string} command causes
EMACS to pause at each instance of the found string.
For example, assume we want to replace some instances of the word
``desktop" with the word ``personal." Go back to the beginning of the
current buffer and enter the {\bf{}M-\^{}R} {\it{}query-replace-string}
command.  The procedure is very similar to that
which you followed in the unconditional search/replace option.  When the
search begins however, you will notice that EMACS pauses at each
instance of ``desktop" and asks whether you wish to replace it with
the replacement string.  You have a number of options available for
response:
\begin{tabular}{lp{5.5in}}
Response & Effect\\ \hline
Y(es) &Make the current replacement and skip to the next
occurance of the search string\\
N(o) & Do not make this replacement but continue\\
! & Do the rest of the replacements with no more queries\\
U(ndo) & Undo just the last replacement and query for it
again (This can only go back ONE time)\\
\^{}G & Abort the replacement command (This action does not
undo previously-authorized replacements\\
. & Same effect as \^{}G, but cursor returns to the point at
which the replacement command was given\\
? & This lists help for the query replacement command\\
\end{tabular}
Practice searching and replacing until you feel
comfortable with the commands and their effects.
\section{Chapter \thechapter{} Summary}
In this chapter, you learned how to search for specified strings of text
in EMACS.  The chapter also dealt with searching for and replacing
elements within a buffer.
\begin{tabular}{llp{4in}}
Key Binding & Keystroke & Effect \\ \hline
Search-Forward & {\bf{}\^{}S} & Searches from point to end of buffer.
Point is moved from current location to
the end of the found string \\
Search-Backward & {\bf{}\^{}R} & Searches from point to beginning of
buffer.  Point is moved from current location to beginning of found
string \\
Replace & {\bf{}M-R} & Replace ALL ocurrences of search string with
specified (null) string from point to the
end of the current buffer \\
Query-Replace-String & {\bf{}M-\^{}R} & As above, but pause at each
found string and query for action \\
\end{tabular}
\chapter{Windows}
\section{Creating Windows}
We have already met windows in an earlier chapter.  In this chapter, we
will explore one of EMACS' more powerful features -- text manipulation
through multiple windowing.
You will recall that windows are areas of buffer text that you can see
\index{window} on the screen.  Because EMACS can support several screen
windows simultaneously you can use them to look into different places in
the same buffer.  You can also use them to look at text in different
buffers.  In effect, you can edit several files at the same time.
Let's invoke EMACS and pull back our file on desktop publishing by
typing
\begin{verbatim}
        emacs publish.txt
\end{verbatim}
When the text appears, type the {\bf{}\^{}X-2} {\it{}split-current-window}
\index{split-current-window} command.  The window splits into two
windows.  The window where the cursor resides is called the {\bf{}current}
window -- in this case the bottom window.  Notice that each window has a
text area and a mode line.  The {\bf{}command line} is however, common to
all windows on the screen.
The two windows on your screen are virtually mirror images of each other
because the new window is opened into the same buffer as the one you are
in when you issue the Open-Window command.  All commands issued to EMACS
are executed on the current buffer in the current window.
To move the cursor to the upper window (i.e., to make that window the
current window, type {\bf{}\^{}X-P} {\it{}previous-window}
\index{previous-window}.  Notice the cursor moves to the upper or
{\bf{}previous} window.  Entering {\bf{}\^{}X-O} {\it{}next-window}
moves to the {\bf{}next} window.  Practice moving between windows.
You will notice that you can also move into the Function Key menu by
entering these commands.
Now move to the upper window.  Let's open a new file.  On the EMACS disk
is a tutorial file.  Let's call it into the upper window by typing:
\begin{verbatim}
        ^X^F emacs.tut
\end{verbatim}
In a short time, the tutorial file will appear in the window.  We now
have two windows on the screen, each looking into different buffers.
We have just used the {\bf{}\^{}X-\^{}F} {\it{}find-file}
\index{find-file} command to find a file and bring it into our current
window.
You can scroll any window up and down with the cursor keys, or with
the commands we've learned so far.  However, because the area of
visible text in each window is relatively small, you can scroll the
current window a line at a time --- Type {\bf{}\^{}X-\^{}N}
{\it{}move-window-down} \index{move-window-down}
The current window scrolls down by one line -- the top line of text
scrolls out of view, and the bottom line moves towards the top of the
screen.  You can imagine, if you like, the whole window slowly moving
down to the end of the buffer in increments of one line.  The command
{\bf{}\^{}X-\^{}P} {\it{}move-window-up} \index{move-window-up}
scrolls the window in the opposite direction.
As we have seen, EMACS editing commands are executed in the current
window, but the program does support a useful feature that allows you to
scroll the {\bf{}next} window.  {\bf{}M-\^{}Z} {\it{}scroll-next-up}
\index{scroll-next-up} scrolls the next window up, {\bf{}M-\^{}U}
{\it{}scroll-next-down} \index{scroll-next-down} scrolls it downward.  From
the tutorial window, practice scrolling the window with the desktop
publishing text in it up and down.
When you're finished, exit EMACS without saving any changes in your
files.
Windows offer you a powerful and easy way to edit text.  By
manipulating a number of windows and buffers on the screen
simultaneously, you can perform complete edits and revisions on the
computer screen while having your draft text or original data
available for reference in another window.
Experiment with splitting the windows on your screen.  Open windows into
different buffers and experiment with any other files you may have.  Try
editing the text in each window, but
don't forget to save any changes you want to keep -- you still have to
save each buffer separately.
%\newpage
\section{Chapter \thechapter{} Summary}
In Chapter \thechapter{} you learned how to manipulate windows and the
editing flexibility they offer.
\begin{tabular}{llp{280pt}}
Key Binding & Keystroke & Effect \\ \hline
Open-Window & {\bf{}\^{}X-2} & Splits current window into two windows
if space is available \\
Close-Windows & {\bf{}\^{}X-1} & Closes all windows except current
window \\
Next-Window & {\bf{}\^{}X-O} & Moves point into next (i.e. downward)
window \\
Previous-Window & {\bf{}\^{}X-P}  & Moves point to previous (i.e. upward)
window \\
Move-Window-Down & {\bf{}\^{}X-\^{}N} & Scrolls current window down
one line \\
Move-Window-Up & {\bf{}\^{}X-\^{}P} & Scrolls current window up one line \\
Redraw-display & {\bf{}M-!} or {\bf{}M-\^{}L} & Window is moved so
line with point (with cursor) is at center of window \\
Grow-Window & {\bf{}\^{}X-\^{}} & Current window is enlarged by one
line and nearest window is shrunk by
one line \\
Shrink-Window & {\bf{}\^{}X-\^{}Z}  & Current window is shrunk by one line
and nearest window is enlarged by one
line \\
Clear-and-Redraw & {\bf{}\^{}L} & Screen is blanked and redrawn.  Keeps
screen updates in sync with your
commands \\
Scroll-Next-Up & {\bf{}M-\^{}Z}  & Scrolls next window up by one line \\
Scroll-Next-Down & {\bf{}M-\^{}U}  & Scrolls next window down by one line \\
\end{tabular}
\chapter{Buffers}
\index{buffer} We have already learned a number of things about
buffers.  As you will recall, they are the major internal entities in
EMACS -- the place where editing commands are executed.  They are
characterized by their {\bf{}names}, their {\bf{}modes}, and by the
file with which they are associated.  Each buffer also ``remembers"
its {\bf{}mark} and {\bf{}point}.  This convenient feature allows you
to go to other buffers and return to the original location in the
``current" buffer.
Advanced users of EMACS frequently have a number of buffers in the
computer's memory simultaneously.  In the last chapter, for example,
you opened at least two buffers -- one into the text you were editing,
and the other into the EMACS on-line tutorial.  If you deal with
complex text files -- say, sectioned chapters of a book, you may have
five or six buffers in the computer's memory.  You could select
different buffers by simply calling up the file with
{\bf{}\^{}X-\^{}F} {\it{}find-file} \index{find-file}, and let EMACS
open or reopen the buffer.  However, EMACS offers fast and
sophisticated buffering techniques that you will find easy to master
and much more convenient to use.
Let's begin by opening three buffers.  You can open any three you
choose, for example call the following files into memory: {\bf{}fang.txt},
{\bf{}publish.txt}, and {\bf{}emacs.tut} in the order listed here.  When
you've finished this process, you'll be looking at a screen showing the
EMACS tutorial.
Let's assume that you want to move to the fang.txt buffer --- Enter
{\bf{}\^{}X-X} {\it{}next-buffer} \index{next-buffer}.
This command moves you to the \underline{next} buffer.  Because EMACS
cycles through the buffer list, which is alphabetized, you will now be
in the {\bf{}fang.txt} buffer. Using {\bf{}\^{}X-X} again places you
in the {\bf{}publish.txt} buffer. {\it{}If you are on a machine that
supports function keys, using {\bf{}\^{}X-X} again places you in the
{\bf{}Function Keys} buffer}. Using {\bf{}\^{}X-X} one last time
cycles you back to the beginning of the list.
If you have a large number of buffers to deal with, this cycling
process may be slow and inconvenient.  The command {\bf{}\^{}X-B}
{\it{}select-buffer} \index{select-buffer} allows you to specify the
buffer you wish to be switched to.  When the command is entered, EMACS
prompts, ``Use buffer:".  Simply enter the buffer name (NOT the file
name), and that buffer will then become the current buffer.
Multiple buffer manipulation and editing is a complex activity, and
you will probably find it very inconvenient to re-save each buffer as
you modify it.  The command {\bf{}\^{}X-\^{}B} {\it{}list-buffers}
\index{list-buffers} creates a new window that gives details about all
the buffers currently known to EMACS.  Buffers that have been modified
are identified by the ``buffer changed" indicator (an asterisk in the
second column).  You can thus quickly and easily identify buffers that
need to be saved to files before you exit EMACS.  The buffer window
also provides other information -- buffer specific modes, buffer size,
and buffer name are also listed.  To close this window, simply type
the close-windows command, {\bf{}\^{}X-1}.
To delete any buffer, type {\bf{}\^{}X-K} {\it{}delete-buffer}
\index{delete-buffer}.  EMACS prompts you ``Kill buffer:".  Enter the
buffer name you want to delete.  As this is destructive command, EMACS
will ask for confirmation if the buffer was changed and not saved.
Answer Y(es) or N(o).  As usual {\bf{}\^{}G} cancels the command.
%\newpage
\section{Chapter \thechapter{} Summary}
In Chapter \thechapter{} you learned how to manipulate buffers.
\begin{tabular}{llp{4in}}
Key Binding & Keystroke & Effect\\ \hline
Next-Buffer & {\bf{}\^{}X-X} & Switch to the next buffer in the buffer
list\\
Select-Buffer & {\bf{}\^{}X-B} & Switch to a particular buffer\\
List-Buffers & {\bf{}\^{}X-\^{}B} & List all buffers\\
Delete-Buffer & {\bf{}\^{}X-K} & delete a particular buffer if it is
off-screen\\
\end{tabular}
\chapter{Modes}
EMACS allows you to change the way it works in order to customize it
to the style of editing you are using.  It does this by providing a
number of different {\bf{}modes} \index{modes}.  These modes can
effect either a single buffer, or any new buffer that is created.  To
add a mode to the current buffer, type {\bf{}\^{}X-M} {\it{}add-mode}
\index{add-mode}.  EMACS will then prompt you for the name of a mode
to add.  When you type in a legal mode name, and type a $<${}NL$>${},
EMACS will add the mode name to the list of current mode names in the
modeline of the current buffer.
To remove an existing mode, typing the {\bf{}\^{}X-\^{}M} {\it{}delete-mode}
\index{delete-mode} will cause EMACS to prompt you for the name of a
mode to delete from the current buffer.  This will remove that mode from
the mode list on the current modeline.
Global modes are the modes which are inherited by any new
buffers which are created.  For example, if you wish to always do string
searching with character case being significant, you would want global
mode EXACT to be set so that any new files read in inherit the EXACT
mode.  Global modes are set with the {\bf{}M-M} {\it{}add-global-mode}
\index{add-global-mode} command, and unset with the {\bf{}M-\^{}M}
{\it{}delete-global-mode} \index{delete-global-mode} command.  Also, the
current global modes are displayed in the first line of a
{\bf{}\^{}X-\^{}B} {\it{}list-buffers} \index{list-buffers} command.
On machines which are capable of displaying colors, \index{color} the
mode commands can also set the background and forground character
colors.  Using {\it{}add-mode} or {\it{}delete-mode} with a lowercase
color will set the background color in the current window.  An
uppercase color will set the forground color in the current window.
Colors that EMACS knows about are: white, cyan, magenta, yellow, blue,
red, green, and black.  If the computer you are running on does not
have eight colors, EMACS will attempt to make some intellegent guess
at what color to use when you ask for one which is not there.
\section{ASAVE mode}
Automatic Save mode tells EMACS to automatically write out the
current buffer to its associated file on a regular basis.  Normally this
will be every 256 characters typed into the file.  The environment
variable \$ACOUNT counts down to the next auto-save, and \$ASAVE is the
value used to reset \$ACOUNT after a save occurs.
\section{CMODE mode}
CMODE is useful to C programmers.  When CMODE is active, EMACS
will try to assist the user in a number of ways.  This mode is set
automatically with files that have a .c or .h extension.
The $<${}NL$>${} key will normally attempt to return the user to the next
line at the same level of indentation as the current line, unless the
current line ends with a open brace (\{) in which case the new line will
be further indented by one tab position.
A close brace (\}) will delete one tab position preceeding itself
as it is typed.  This should line up the close brace with its matching
IF, FOR or WHILE statement.
A pound sign (\#) with only leading whitespace will delete all
the whitespace preceeding itself. This will always bring preprocessor
directives flush to the left margin.
Whenever any close fence is typed, ie )]$>${}\}, if the matching open
fence is on screen in the current window, the cursor will breifly flash
to it, and then back. This makes balencing expressions, and matching
blocks much easier.
\section{CRYPT mode}
When a buffer is in CRYPT mode, \index{encryption} it is
encrypted whenever it is written to a file, and decrypted when it is
read from the file.  The encryption key can be specified on the command
line with the -k switch, or with the {\bf{}M-E} {\it{}set-encryption-key}
\index{set-encryption-key} command.  If you attempt to read or write a
buffer in crypt mode and the key has not been set, EMACS will execute
{\it{}set-encryption-key} automatically, prompting you for the needed key.
Whenever EMACS prompts you for a key, it will not echo the key to your
screen as you type it (ie make SURE you get it right when you set it
originally).
The encryption algorithm used changes all characters into normal
printing characters, thus the resulting file is suitable for sending via
electronic mail.  All versions of MicroEMACS should be able to decrypt the
resulting file regardless of what machine encrypted it.  Also available
with EMACS is the stand alone program, MicroCRYPT, which can en/decrypt
the files produced by CRYPT mode in EMACS.
\section{EXACT mode}
All string searches and replacements will take upper/lower case
into account. Normally the case of a string during a search or replace
is not taken into account.
\section{MAGIC mode}
     In MAGIC mode certain characters gain special meanings when
used in a search pattern.  Collectively they are know as regular
expressions, and a limited number of them are supported in MicroEmacs.
They grant greater flexability when using the search command.  However,
they do not affect the incremental search command.
     The symbols that have special meaning in MAGIC mode are
\^{}, \$, ., *, [ (and ], used with it), and $\backslash${}.
     The characters \^{} and \$ fix the search pattern to the
beginning and end of line, respectively.  The \^{} character must
appear at the beginning of the search string, and the \$ must appear
at the end, otherwise they loose their meaning and are treated just
like any other character.  For example, in MAGIC mode, searching for
the pattern ``t\$" would put the cursor at the end of any line that
ended with the letter `t'.  Note that this is different than searching
for ``t$<${}NL$>${}", that is, `t' followed by a newline character.
The character \$ (and \^{}, for that matter) matches a position, not a
character, so the cursor remains at the end of the line.  But a
newline is a character that must be matched, just like any other
character, which means that the cursor is placed just after it --- on
the beginning of the next line.
     The character .  has a very simple meaning -- it matches any single
character, except the newline.  Thus a search for ``bad.er" could match
``badger", ``badder" (slang), or up to the `r' of ``bad error".
     The character * is known as closure, and means that zero or more of
the preceding character will match.  If there is no character preceding,
* has no special meaning, and since it will not match with a newline, *
will have no special meaning if preceded by the beginning of line symbol
\^{} or the literal newline character $<${}NL$>${}.
     The notion of zero or more characters is important.  If, for
example, your cursor was on the line
\begin{verbatim}
        This line is missing two vowels.
\end{verbatim}
and a search was made for ``a*", the cursor would not move, because it is
guarenteed to match no letter `a', which satifies the search
conditions.  If you wanted to search for one or more of the letter `a',
you would search for ``aa*", which would match the letter a, then zero or
more of them.
     The character [ indicates the beginning of a character class.  It
is similar to the `any' character ., but you get to choose which
characters you want to match.  The character class is ended with the
character ].  So, while a search for ``ba.e" will match ``bane", ``bade",
``bale", ``bate", et cetera, you can limit it to matching ``babe" and
``bake" by searching for ``ba[bk]e".  Only one of the characters inside
the [ and ] will match a character.  If in fact you want to match any
character except those in the character class, you can put a \^{} as the
first character.  It must be the first character of the class, or else
it has no special meaning.  So, a search for [\^{}aeiou] will match any
character except a vowel, but a search for [aeiou\^{}] will match any vowel
or a \^{}.
If you have a lot of characters in order that you want to put in the
character class, you may use a dash (-) as a range character.  So, [a-z]
will match any letter (or any lower case letter if EXACT mode is on),
and [0-9a-f] will match any digit or any letter `a' through `f', which
happen to be the characters for hexadecimal numbers.  If the dash is at
the beginning or end of a character class, it is taken to be just a
dash.
     The escape character $\backslash${} is for those times when you
want to be in MAGIC mode, but also want to use a regular expression
character to be just a character.  It turns off the special meaning of
the character.  So a search for ``it$\backslash${}." will search for a
line with ``it.", and not ``it" followed by any other character.  The
escape character will also let you put \^{}, -, or ] inside a
character class with no special side effects.
\section{OVER mode}
OVER mode stands for overwrite mode.  When in this mode, when
characters are typed, instead of simply inserting them into the file,
EMACS will attempt to overwrite an existing character past the point.
This is very useful for adjusting tables and diagrams.
\section{WRAP mode}
Wrap mode is used when typing in continuous text.  Whenever the cursor
is past the currently set fill column \index{fill column} (72 by
default) and the user types a space or a $<${}NL$>${}, the last word
of the line is brought down to the beginning of the next line.  Using
this, one just types a continous stream of words and EMACS
automatically inserts $<${}NL$>${}s at appropriate places.
{\bf NOTE to programmers:}
EMACS actually calls up the function bound to the illegal
keystroke M-FNW.  This is bound to the function {\it{}wrap-word}
\index{wrap-word} by default, but can be re-bound to activate different
functions and macros at wrap time.
\section{VIEW mode}
VIEW mode disables all commands which can change the current
buffer.  EMACS will display an error message and ring the bell every
time you attempt to change a buffer in VIEW mode.
%\newpage
\section{Chapter \thechapter{} Summary}
In Chapter \thechapter{} you learned about modes and their effects.
\begin{tabular}{llp{4in}}
Key Binding & Keystroke & Effect \\ \hline
Add-Mode & {\bf{}\^{}X-M} & Add a mode to the current buffer\\
Delete-Mode & {\bf{}\^{}X-\^{}M} & Delete a mode from the current buffer\\
Add-Global-Mode & {\bf{}M-M} & Add a global mode to the
current buffer\\
Delete-Global-Mode & {\bf{}M-\^{}M} & Delete a global mode from the
current buffer\\
\end{tabular}
\Rogue\Monster\
  echo "will not over write ./part1.tex"
if [ `wc -c ./part1.tex | awk '{printf $1}'` -ne 55930 ]
echo `wc -c ./part1.tex | awk '{print "Got " $1 ", Expected " 55930}'`
echo "Finished archive 2 of 2"