This is ../info/emacs, produced by makeinfo version 4.0 from emacs.texi.

   This is the thirteenth edition of the `GNU Emacs Manual', updated
for Emacs version 20.7.

INFO-DIR-SECTION Editors
START-INFO-DIR-ENTRY
* Emacs: (emacs).	The extensible self-documenting text editor.
END-INFO-DIR-ENTRY

   Published by the Free Software Foundation 59 Temple Place, Suite 330
Boston, MA  02111-1307 USA

   Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998,
1999    Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
General Public License" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under the
terms of a permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "The GNU Manifesto",
"Distribution" and "GNU General Public License" may be included in a
translation approved by the Free Software Foundation instead of in the
original English.


File: emacs,  Node: Copying,  Next: Intro,  Prev: Distrib,  Up: Top

GNU GENERAL PUBLIC LICENSE
**************************

                         Version 2, June 1991

     Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     
     Everyone is permitted to copy and distribute verbatim copies
     of this license document, but changing it is not allowed.

Preamble
========

   The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

   When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it in
new free programs; and that you know you can do these things.

   To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

   For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

   We protect your rights with two steps: (1) copyright the software,
and (2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

   Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

   Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

   The precise terms and conditions for copying, distribution and
modification follow.

    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains a
     notice placed by the copyright holder saying it may be distributed
     under the terms of this General Public License.  The "Program",
     below, refers to any such program or work, and a "work based on
     the Program" means either the Program or any derivative work under
     copyright law: that is to say, a work containing the Program or a
     portion of it, either verbatim or with modifications and/or
     translated into another language.  (Hereinafter, translation is
     included without limitation in the term "modification".)  Each
     licensee is addressed as "you".

     Activities other than copying, distribution and modification are
     not covered by this License; they are outside its scope.  The act
     of running the Program is not restricted, and the output from the
     Program is covered only if its contents constitute a work based on
     the Program (independent of having been made by running the
     Program).  Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
     source code as you receive it, in any medium, provided that you
     conspicuously and appropriately publish on each copy an appropriate
     copyright notice and disclaimer of warranty; keep intact all the
     notices that refer to this License and to the absence of any
     warranty; and give any other recipients of the Program a copy of
     this License along with the Program.

     You may charge a fee for the physical act of transferring a copy,
     and you may at your option offer warranty protection in exchange
     for a fee.

  2. You may modify your copy or copies of the Program or any portion
     of it, thus forming a work based on the Program, and copy and
     distribute such modifications or work under the terms of Section 1
     above, provided that you also meet all of these conditions:

       a. You must cause the modified files to carry prominent notices
          stating that you changed the files and the date of any change.

       b. You must cause any work that you distribute or publish, that
          in whole or in part contains or is derived from the Program
          or any part thereof, to be licensed as a whole at no charge
          to all third parties under the terms of this License.

       c. If the modified program normally reads commands interactively
          when run, you must cause it, when started running for such
          interactive use in the most ordinary way, to print or display
          an announcement including an appropriate copyright notice and
          a notice that there is no warranty (or else, saying that you
          provide a warranty) and that users may redistribute the
          program under these conditions, and telling the user how to
          view a copy of this License.  (Exception: if the Program
          itself is interactive but does not normally print such an
          announcement, your work based on the Program is not required
          to print an announcement.)

     These requirements apply to the modified work as a whole.  If
     identifiable sections of that work are not derived from the
     Program, and can be reasonably considered independent and separate
     works in themselves, then this License, and its terms, do not
     apply to those sections when you distribute them as separate
     works.  But when you distribute the same sections as part of a
     whole which is a work based on the Program, the distribution of
     the whole must be on the terms of this License, whose permissions
     for other licensees extend to the entire whole, and thus to each
     and every part regardless of who wrote it.

     Thus, it is not the intent of this section to claim rights or
     contest your rights to work written entirely by you; rather, the
     intent is to exercise the right to control the distribution of
     derivative or collective works based on the Program.

     In addition, mere aggregation of another work not based on the
     Program with the Program (or with a work based on the Program) on
     a volume of a storage or distribution medium does not bring the
     other work under the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
     under Section 2) in object code or executable form under the terms
     of Sections 1 and 2 above provided that you also do one of the
     following:

       a. Accompany it with the complete corresponding machine-readable
          source code, which must be distributed under the terms of
          Sections 1 and 2 above on a medium customarily used for
          software interchange; or,

       b. Accompany it with a written offer, valid for at least three
          years, to give any third party, for a charge no more than your
          cost of physically performing source distribution, a complete
          machine-readable copy of the corresponding source code, to be
          distributed under the terms of Sections 1 and 2 above on a
          medium customarily used for software interchange; or,

       c. Accompany it with the information you received as to the offer
          to distribute corresponding source code.  (This alternative is
          allowed only for noncommercial distribution and only if you
          received the program in object code or executable form with
          such an offer, in accord with Subsection b above.)

     The source code for a work means the preferred form of the work for
     making modifications to it.  For an executable work, complete
     source code means all the source code for all modules it contains,
     plus any associated interface definition files, plus the scripts
     used to control compilation and installation of the executable.
     However, as a special exception, the source code distributed need
     not include anything that is normally distributed (in either
     source or binary form) with the major components (compiler,
     kernel, and so on) of the operating system on which the executable
     runs, unless that component itself accompanies the executable.

     If distribution of executable or object code is made by offering
     access to copy from a designated place, then offering equivalent
     access to copy the source code from the same place counts as
     distribution of the source code, even though third parties are not
     compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
     except as expressly provided under this License.  Any attempt
     otherwise to copy, modify, sublicense or distribute the Program is
     void, and will automatically terminate your rights under this
     License.  However, parties who have received copies, or rights,
     from you under this License will not have their licenses
     terminated so long as such parties remain in full compliance.

  5. You are not required to accept this License, since you have not
     signed it.  However, nothing else grants you permission to modify
     or distribute the Program or its derivative works.  These actions
     are prohibited by law if you do not accept this License.
     Therefore, by modifying or distributing the Program (or any work
     based on the Program), you indicate your acceptance of this
     License to do so, and all its terms and conditions for copying,
     distributing or modifying the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
     Program), the recipient automatically receives a license from the
     original licensor to copy, distribute or modify the Program
     subject to these terms and conditions.  You may not impose any
     further restrictions on the recipients' exercise of the rights
     granted herein.  You are not responsible for enforcing compliance
     by third parties to this License.

  7. If, as a consequence of a court judgment or allegation of patent
     infringement or for any other reason (not limited to patent
     issues), conditions are imposed on you (whether by court order,
     agreement or otherwise) that contradict the conditions of this
     License, they do not excuse you from the conditions of this
     License.  If you cannot distribute so as to satisfy simultaneously
     your obligations under this License and any other pertinent
     obligations, then as a consequence you may not distribute the
     Program at all.  For example, if a patent license would not permit
     royalty-free redistribution of the Program by all those who
     receive copies directly or indirectly through you, then the only
     way you could satisfy both it and this License would be to refrain
     entirely from distribution of the Program.

     If any portion of this section is held invalid or unenforceable
     under any particular circumstance, the balance of the section is
     intended to apply and the section as a whole is intended to apply
     in other circumstances.

     It is not the purpose of this section to induce you to infringe any
     patents or other property right claims or to contest validity of
     any such claims; this section has the sole purpose of protecting
     the integrity of the free software distribution system, which is
     implemented by public license practices.  Many people have made
     generous contributions to the wide range of software distributed
     through that system in reliance on consistent application of that
     system; it is up to the author/donor to decide if he or she is
     willing to distribute software through any other system and a
     licensee cannot impose that choice.

     This section is intended to make thoroughly clear what is believed
     to be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
     certain countries either by patents or by copyrighted interfaces,
     the original copyright holder who places the Program under this
     License may add an explicit geographical distribution limitation
     excluding those countries, so that distribution is permitted only
     in or among countries not thus excluded.  In such case, this
     License incorporates the limitation as if written in the body of
     this License.

  9. The Free Software Foundation may publish revised and/or new
     versions of the General Public License from time to time.  Such
     new versions will be similar in spirit to the present version, but
     may differ in detail to address new problems or concerns.

     Each version is given a distinguishing version number.  If the
     Program specifies a version number of this License which applies
     to it and "any later version", you have the option of following
     the terms and conditions either of that version or of any later
     version published by the Free Software Foundation.  If the Program
     does not specify a version number of this License, you may choose
     any version ever published by the Free Software Foundation.

 10. If you wish to incorporate parts of the Program into other free
     programs whose distribution conditions are different, write to the
     author to ask for permission.  For software which is copyrighted
     by the Free Software Foundation, write to the Free Software
     Foundation; we sometimes make exceptions for this.  Our decision
     will be guided by the two goals of preserving the free status of
     all derivatives of our free software and of promoting the sharing
     and reuse of software generally.

                                NO WARRANTY

 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO
     WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
     LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
     HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
     WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
     NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
     FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE
     QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
     PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
     SERVICING, REPAIR OR CORRECTION.

 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
     WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
     MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE
     LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
     INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
     INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
     DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
     OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY
     OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
     ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

                      END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs
=============================================

   If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these
terms.

   To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

     ONE LINE TO GIVE THE PROGRAM'S NAME AND AN IDEA OF WHAT IT DOES.
     Copyright (C) 19YY  NAME OF AUTHOR
     
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     as published by the Free Software Foundation; either version 2
     of the License, or (at your option) any later version.
     
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

   Also add information on how to contact you by electronic and paper
mail.

   If the program is interactive, make it output a short notice like
this when it starts in an interactive mode:

     Gnomovision version 69, Copyright (C) 19YY NAME OF AUTHOR
     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
     type `show w'.  This is free software, and you are welcome
     to redistribute it under certain conditions; type `show c'
     for details.

   The hypothetical commands `show w' and `show c' should show the
appropriate parts of the General Public License.  Of course, the
commands you use may be called something other than `show w' and `show
c'; they could even be mouse-clicks or menu items--whatever suits your
program.

   You should also get your employer (if you work as a programmer) or
your school, if any, to sign a "copyright disclaimer" for the program,
if necessary.  Here is a sample; alter the names:

     Yoyodyne, Inc., hereby disclaims all copyright
     interest in the program `Gnomovision'
     (which makes passes at compilers) written
     by James Hacker.
     
     SIGNATURE OF TY COON, 1 April 1989
     Ty Coon, President of Vice

   This General Public License does not permit incorporating your
program into proprietary programs.  If your program is a subroutine
library, you may consider it more useful to permit linking proprietary
applications with the library.  If this is what you want to do, use the
GNU Library General Public License instead of this License.


File: emacs,  Node: Intro,  Next: Glossary,  Prev: Copying,  Up: Top

Introduction
************

   You are reading about GNU Emacs, the GNU incarnation of the advanced,
self-documenting, customizable, extensible real-time display editor
Emacs.  (The `G' in `GNU' is not silent.)

   We say that Emacs is a "display" editor because normally the text
being edited is visible on the screen and is updated automatically as
you type your commands.  *Note Display: Screen.

   We call it a "real-time" editor because the display is updated very
frequently, usually after each character or pair of characters you
type.  This minimizes the amount of information you must keep in your
head as you edit.  *Note Real-time: Basic.

   We call Emacs advanced because it provides facilities that go beyond
simple insertion and deletion: controlling subprocesses; automatic
indentation of programs; viewing two or more files at once; editing
formatted text; and dealing in terms of characters, words, lines,
sentences, paragraphs, and pages, as well as expressions and comments in
several different programming languages.

   "Self-documenting" means that at any time you can type a special
character, `Control-h', to find out what your options are.  You can
also use it to find out what any command does, or to find all the
commands that pertain to a topic.  *Note Help::.

   "Customizable" means that you can change the definitions of Emacs
commands in little ways.  For example, if you use a programming
language in which comments start with `<**' and end with `**>', you can
tell the Emacs comment manipulation commands to use those strings
(*note Comments::).  Another sort of customization is rearrangement of
the command set.  For example, if you prefer the four basic cursor
motion commands (up, down, left and right) on keys in a diamond pattern
on the keyboard, you can rebind the keys that way.  *Note
Customization::.

   "Extensible" means that you can go beyond simple customization and
write entirely new commands, programs in the Lisp language to be run by
Emacs's own Lisp interpreter.  Emacs is an "on-line extensible" system,
which means that it is divided into many functions that call each
other, any of which can be redefined in the middle of an editing
session.  Almost any part of Emacs can be replaced without making a
separate copy of all of Emacs.  Most of the editing commands of Emacs
are written in Lisp already; the few exceptions could have been written
in Lisp but are written in C for efficiency.  Although only a programmer
can write an extension, anybody can use it afterward.  If you want to
learn Emacs Lisp programming, we recommend the `Introduction to Emacs
Lisp' by Robert J. Chassell, also published by the Free Software
Foundation.

   When run under the X Window System, Emacs provides its own menus and
convenient bindings to mouse buttons.  But Emacs can provide many of the
benefits of a window system on a text-only terminal.  For instance, you
can look at or edit several files at once, move text between files, and
edit files while running shell commands.


File: emacs,  Node: Screen,  Next: User Input,  Prev: Acknowledgments,  Up: Top

The Organization of the Screen
******************************

   On a text-only terminal, the Emacs display occupies the whole screen.
On the X Window System, Emacs creates its own X windows to use.  We use
the term "frame" to mean an entire text-only screen or an entire X
window used by Emacs.  Emacs uses both kinds of frames in the same way
to display your editing.  Emacs normally starts out with just one frame,
but you can create additional frames if you wish.  *Note Frames::.

   When you start Emacs, the entire frame except for the first and last
lines is devoted to the text you are editing.  This area is called the
"window".  The first line is a "menu bar", and the last line is a
special "echo area" or "minibuffer window" where prompts appear and
where you can enter responses.  See below for more information about
these special lines.

   You can subdivide the large text window horizontally or vertically
into multiple text windows, each of which can be used for a different
file (*note Windows::).  In this manual, the word "window" always
refers to the subdivisions of a frame within Emacs.

   The window that the cursor is in is the "selected window", in which
editing takes place.  Most Emacs commands implicitly apply to the text
in the selected window (though mouse commands generally operate on
whatever window you click them in, whether selected or not).  The other
windows display text for reference only, unless/until you select them.
If you use multiple frames under the X Window System, then giving the
input focus to a particular frame selects a window in that frame.

   Each window's last line is a "mode line", which describes what is
going on in that window.  It appears in inverse video, if the terminal
supports that, and its contents begin with `--:--  *scratch*' when
Emacs starts.  The mode line displays status information such as what
buffer is being displayed above it in the window, what major and minor
modes are in use, and whether the buffer contains unsaved changes.

* Menu:

* Point::	        The place in the text where editing commands operate.
* Echo Area::           Short messages appear at the bottom of the screen.
* Mode Line::	        Interpreting the mode line.
* Menu Bar::            How to use the menu bar.


File: emacs,  Node: Point,  Next: Echo Area,  Up: Screen

Point
=====

   Within Emacs, the terminal's cursor shows the location at which
editing commands will take effect.  This location is called "point".
Many Emacs commands move point through the text, so that you can edit at
different places in it.  You can also place point by clicking mouse
button 1.

   While the cursor appears to point _at_ a character, you should think
of point as _between_ two characters; it points _before_ the character
that appears under the cursor.  For example, if your text looks like
`frob' with the cursor over the `b', then point is between the `o' and
the `b'.  If you insert the character `!' at that position, the result
is `fro!b', with point between the `!' and the `b'.  Thus, the cursor
remains over the `b', as before.

   Sometimes people speak of "the cursor" when they mean "point," or
speak of commands that move point as "cursor motion" commands.

   Terminals have only one cursor, and when output is in progress it
must appear where the typing is being done.  This does not mean that
point is moving.  It is only that Emacs has no way to show you the
location of point except when the terminal is idle.

   If you are editing several files in Emacs, each in its own buffer,
each buffer has its own point location.  A buffer that is not currently
displayed remembers where point is in case you display it again later.

   When there are multiple windows in a frame, each window has its own
point location.  The cursor shows the location of point in the selected
window.  This also is how you can tell which window is selected.  If the
same buffer appears in more than one window, each window has its own
position for point in that buffer.

   When there are multiple frames, each frame can display one cursor.
The cursor in the selected frame is solid; the cursor in other frames is
a hollow box, and appears in the window that would be selected if you
give the input focus to that frame.

   The term `point' comes from the character `.', which was the command
in TECO (the language in which the original Emacs was written) for
accessing the value now called `point'.


File: emacs,  Node: Echo Area,  Next: Mode Line,  Prev: Point,  Up: Screen

The Echo Area
=============

   The line at the bottom of the frame (below the mode line) is the
"echo area".  It is used to display small amounts of text for several
purposes.

   "Echoing" means displaying the characters that you type.  Outside
Emacs, the operating system normally echoes all your input.  Emacs
handles echoing differently.

   Single-character commands do not echo in Emacs, and multi-character
commands echo only if you pause while typing them.  As soon as you pause
for more than a second in the middle of a command, Emacs echoes all the
characters of the command so far.  This is to "prompt" you for the rest
of the command.  Once echoing has started, the rest of the command
echoes immediately as you type it.  This behavior is designed to give
confident users fast response, while giving hesitant users maximum
feedback.  You can change this behavior by setting a variable (*note
Display Vars::).

   If a command cannot be executed, it may print an "error message" in
the echo area.  Error messages are accompanied by a beep or by flashing
the screen.  Also, any input you have typed ahead is thrown away when
an error happens.

   Some commands print informative messages in the echo area.  These
messages look much like error messages, but they are not announced with
a beep and do not throw away input.  Sometimes the message tells you
what the command has done, when this is not obvious from looking at the
text being edited.  Sometimes the sole purpose of a command is to print
a message giving you specific information--for example, `C-x =' prints
a message describing the character position of point in the text and
its current column in the window.  Commands that take a long time often
display messages ending in `...' while they are working, and add `done'
at the end when they are finished.

   Echo-area informative messages are saved in an editor buffer named
`*Messages*'.  (We have not explained buffers yet; see *Note Buffers::,
for more information about them.)  If you miss a message that appears
briefly on the screen, you can switch to the `*Messages*' buffer to see
it again.  (Successive progress messages are often collapsed into one
in that buffer.)

   The size of `*Messages*' is limited to a certain number of lines.
The variable `message-log-max' specifies how many lines.  Once the
buffer has that many lines, each line added at the end deletes one line
from the beginning.  *Note Variables::, for how to set variables such as
`message-log-max'.

   The echo area is also used to display the "minibuffer", a window that
is used for reading arguments to commands, such as the name of a file
to be edited.  When the minibuffer is in use, the echo area begins with
a prompt string that usually ends with a colon; also, the cursor
appears in that line because it is the selected window.  You can always
get out of the minibuffer by typing `C-g'.  *Note Minibuffer::.


File: emacs,  Node: Mode Line,  Next: Menu Bar,  Prev: Echo Area,  Up: Screen

The Mode Line
=============

   Each text window's last line is a "mode line", which describes what
is going on in that window.  When there is only one text window, the
mode line appears right above the echo area; it is the next-to-last line
on the frame.  The mode line is in inverse video if the terminal
supports that, and it starts and ends with dashes.

   Normally, the mode line looks like this:

     -CS:CH  BUF      (MAJOR MINOR)--LINE--POS------

This gives information about the buffer being displayed in the window:
the buffer's name, what major and minor modes are in use, whether the
buffer's text has been changed, and how far down the buffer you are
currently looking.

   CH contains two stars `**' if the text in the buffer has been edited
(the buffer is "modified"), or `--' if the buffer has not been edited.
For a read-only buffer, it is `%*' if the buffer is modified, and `%%'
otherwise.

   BUF is the name of the window's "buffer".  In most cases this is the
same as the name of a file you are editing.  *Note Buffers::.

   The buffer displayed in the selected window (the window that the
cursor is in) is also Emacs's selected buffer, the one that editing
takes place in.  When we speak of what some command does to "the
buffer," we are talking about the currently selected buffer.

   LINE is `L' followed by the current line number of point.  This is
present when Line Number mode is enabled (which it normally is).  You
can optionally display the current column number too, by turning on
Column Number mode (which is not enabled by default because it is
somewhat slower).  *Note Optional Mode Line::.

   POS tells you whether there is additional text above the top of the
window, or below the bottom.  If your buffer is small and it is all
visible in the window, POS is `All'.  Otherwise, it is `Top' if you are
looking at the beginning of the buffer, `Bot' if you are looking at the
end of the buffer, or `NN%', where NN is the percentage of the buffer
above the top of the window.

   MAJOR is the name of the "major mode" in effect in the buffer.  At
any time, each buffer is in one and only one of the possible major
modes.  The major modes available include Fundamental mode (the least
specialized), Text mode, Lisp mode, C mode, Texinfo mode, and many
others.  *Note Major Modes::, for details of how the modes differ and
how to select one.

   Some major modes display additional information after the major mode
name.  For example, Rmail buffers display the current message number and
the total number of messages.  Compilation buffers and Shell buffers
display the status of the subprocess.

   MINOR is a list of some of the "minor modes" that are turned on at
the moment in the window's chosen buffer.  For example, `Fill' means
that Auto Fill mode is on.  `Abbrev' means that Word Abbrev mode is on.
`Ovwrt' means that Overwrite mode is on.  *Note Minor Modes::, for
more information.  `Narrow' means that the buffer being displayed has
editing restricted to only a portion of its text.  This is not really a
minor mode, but is like one.  *Note Narrowing::.  `Def' means that a
keyboard macro is being defined.  *Note Keyboard Macros::.

   In addition, if Emacs is currently inside a recursive editing level,
square brackets (`[...]') appear around the parentheses that surround
the modes.  If Emacs is in one recursive editing level within another,
double square brackets appear, and so on.  Since recursive editing
levels affect Emacs globally, not just one buffer, the square brackets
appear in every window's mode line or not in any of them.  *Note
Recursive Edit::.

   Non-windowing terminals can only show a single Emacs frame at a time
(*note Frames::).  On such terminals, the mode line displays the name of
the selected frame, after CH.  The initial frame's name is `F1'.

   CS states the coding system used for the file you are editing.  A
dash indicates the default state of affairs: no code conversion, except
for end-of-line translation if the file contents call for that.  `='
means no conversion whatsoever.  Nontrivial code conversions are
represented by various letters--for example, `1' refers to ISO Latin-1.
*Note Coding Systems::, for more information.  If you are using an
input method, a string of the form `I>' is added to the beginning of
CS; I identifies the input method.  (Some input methods show `+' or `@'
instead of `>'.)  *Note Input Methods::.

   When you are using a character-only terminal (not a window system),
CS uses three characters to describe, respectively, the coding system
for keyboard input, the coding system for terminal output, and the
coding system used for the file you are editing.

   When multibyte characters are not enabled, CS does not appear at
all.  *Note Enabling Multibyte::.

   The colon after CS can change to another string in certain
circumstances.  Emacs uses newline to separate lines in the buffer.
Some files use different conventions for separating lines: either
carriage-return linefeed (the MS-DOS convention) or just carriage-return
(the Macintosh convention).  If the buffer's file uses carriage-return
linefeed, the colon changes to either a backslash (`\') or `(DOS)',
depending on the operating system.  If the file uses just
carriage-return, the colon indicator changes to either a forward slash
(`/') or `(Mac)'.  On some systems, Emacs displays `(Unix)' instead of
the colon even for files that use newline to separate lines.

   You can customize the mode line display for each of the end-of-line
formats by setting each of the variables `eol-mnemonic-unix',
`eol-mnemonic-dos', `eol-mnemonic-mac', and `eol-mnemonic-undecided' to
any string you find appropriate.  *Note Variables::, for an explanation
how to set variables.

   *Note Optional Mode Line::, for features that add other handy
information to the mode line, such as the current column number of
point, the current time, and whether new mail for you has arrived.


File: emacs,  Node: Menu Bar,  Prev: Mode Line,  Up: Screen

The Menu Bar
============

   Each Emacs frame normally has a "menu bar" at the top which you can
use to perform certain common operations.  There's no need to list them
here, as you can more easily see for yourself.

   When you are using a window system, you can use the mouse to choose a
command from the menu bar.  An arrow pointing right, after the menu
item, indicates that the item leads to a subsidiary menu; `...' at the
end means that the command will read arguments from the keyboard before
it actually does anything.

   To view the full command name and documentation for a menu item, type
`C-h k', and then select the menu bar with the mouse in the usual way
(*note Key Help::).

   On text-only terminals with no mouse, you can use the menu bar by
typing `M-`' or <F10> (these run the command `tmm-menubar').  This
command enters a mode in which you can select a menu item from the
keyboard.  A provisional choice appears in the echo area.  You can use
the left and right arrow keys to move through the menu to different
choices.  When you have found the choice you want, type <RET> to select
it.

   Each menu item also has an assigned letter or digit which designates
that item; it is usually the initial of some word in the item's name.
This letter or digit is separated from the item name by `=>'.  You can
type the item's letter or digit to select the item.

   Some of the commands in the menu bar have ordinary key bindings as
well; if so, the menu lists one equivalent key binding in parentheses
after the item itself.


File: emacs,  Node: User Input,  Next: Keys,  Prev: Screen,  Up: Top

Kinds of User Input
===================

   GNU Emacs uses an extension of the ASCII character set for keyboard
input; it also accepts non-character input events including function
keys and mouse button actions.

   ASCII consists of 128 character codes.  Some of these codes are
assigned graphic symbols such as `a' and `='; the rest are control
characters, such as `Control-a' (usually written `C-a' for short).
`C-a' gets its name from the fact that you type it by holding down the
<CTRL> key while pressing `a'.

   Some ASCII control characters have special names, and most terminals
have special keys you can type them with: for example, <RET>, <TAB>,
<DEL> and <ESC>.  The space character is usually referred to below as
<SPC>, even though strictly speaking it is a graphic character whose
graphic happens to be blank.  Some keyboards have a key labeled
"linefeed" which is an alias for `C-j'.

   Emacs extends the ASCII character set with thousands more printing
characters (*note International::), additional control characters, and a
few more modifiers that can be combined with any character.

   On ASCII terminals, there are only 32 possible control characters.
These are the control variants of letters and `@[]\^_'.  In addition,
the shift key is meaningless with control characters: `C-a' and `C-A'
are the same character, and Emacs cannot distinguish them.

   But the Emacs character set has room for control variants of all
printing characters, and for distinguishing between `C-a' and `C-A'.  X
Windows makes it possible to enter all these characters.  For example,
`C--' (that's Control-Minus) and `C-5' are meaningful Emacs commands
under X.

   Another Emacs character-set extension is additional modifier bits.
Only one modifier bit is commonly used; it is called Meta.  Every
character has a Meta variant; examples include `Meta-a' (normally
written `M-a', for short), `M-A' (not the same character as `M-a', but
those two characters normally have the same meaning in Emacs),
`M-<RET>', and `M-C-a'.  For reasons of tradition, we usually write
`C-M-a' rather than `M-C-a'; logically speaking, the order in which the
modifier keys <CTRL> and <META> are mentioned does not matter.

   Some terminals have a <META> key, and allow you to type Meta
characters by holding this key down.  Thus, `Meta-a' is typed by
holding down <META> and pressing `a'.  The <META> key works much like
the <SHIFT> key.  Such a key is not always labeled <META>, however, as
this function is often a special option for a key with some other
primary purpose.

   If there is no <META> key, you can still type Meta characters using
two-character sequences starting with <ESC>.  Thus, to enter `M-a', you
could type `<ESC> a'.  To enter `C-M-a', you would type `<ESC> C-a'.
<ESC> is allowed on terminals with <META> keys, too, in case you have
formed a habit of using it.

   X Windows provides several other modifier keys that can be applied to
any input character.  These are called <SUPER>, <HYPER> and <ALT>.  We
write `s-', `H-' and `A-' to say that a character uses these modifiers.
Thus, `s-H-C-x' is short for `Super-Hyper-Control-x'.  Not all X
terminals actually provide keys for these modifier flags--in fact, many
terminals have a key labeled <ALT> which is really a <META> key.  The
standard key bindings of Emacs do not include any characters with these
modifiers.  But you can assign them meanings of your own by customizing
Emacs.

   Keyboard input includes keyboard keys that are not characters at all:
for example function keys and arrow keys.  Mouse buttons are also
outside the gamut of characters.  You can modify these events with the
modifier keys <CTRL>, <META>, <SUPER>, <HYPER> and <ALT>, just like
keyboard characters.

   Input characters and non-character inputs are collectively called
"input events".  *Note Input Events: (elisp)Input Events, for more
information.  If you are not doing Lisp programming, but simply want to
redefine the meaning of some characters or non-character events, see
*Note Customization::.

   ASCII terminals cannot really send anything to the computer except
ASCII characters.  These terminals use a sequence of characters to
represent each function key.  But that is invisible to the Emacs user,
because the keyboard input routines recognize these special sequences
and convert them to function key events before any other part of Emacs
gets to see them.


File: emacs,  Node: Keys,  Next: Commands,  Prev: User Input,  Up: Top

Keys
====

   A "key sequence" ("key", for short) is a sequence of input events
that are meaningful as a unit--as "a single command."  Some Emacs
command sequences are just one character or one event; for example,
just `C-f' is enough to move forward one character.  But Emacs also has
commands that take two or more events to invoke.

   If a sequence of events is enough to invoke a command, it is a
"complete key".  Examples of complete keys include `C-a', `X', <RET>,
<NEXT> (a function key), <DOWN> (an arrow key), `C-x C-f', and `C-x 4
C-f'.  If it isn't long enough to be complete, we call it a "prefix
key".  The above examples show that `C-x' and `C-x 4' are prefix keys.
Every key sequence is either a complete key or a prefix key.

   Most single characters constitute complete keys in the standard Emacs
command bindings.  A few of them are prefix keys.  A prefix key combines
with the following input event to make a longer key sequence, which may
itself be complete or a prefix.  For example, `C-x' is a prefix key, so
`C-x' and the next input event combine to make a two-character key
sequence.  Most of these key sequences are complete keys, including
`C-x C-f' and `C-x b'.  A few, such as `C-x 4' and `C-x r', are
themselves prefix keys that lead to three-character key sequences.
There's no limit to the length of a key sequence, but in practice
people rarely use sequences longer than four events.

   By contrast, you can't add more events onto a complete key.  For
example, the two-character sequence `C-f C-k' is not a key, because the
`C-f' is a complete key in itself.  It's impossible to give `C-f C-k'
an independent meaning as a command.  `C-f C-k' is two key sequences,
not one.

   All told, the prefix keys in Emacs are `C-c', `C-h', `C-x', `C-x
<RET>', `C-x @', `C-x a', `C-x n', `C-x r', `C-x v', `C-x 4', `C-x 5',
`C-x 6', <ESC>, `M-g' and `M-j'.  But this list is not cast in
concrete; it is just a matter of Emacs's standard key bindings.  If you
customize Emacs, you can make new prefix keys, or eliminate these.
*Note Key Bindings::.

   If you do make or eliminate prefix keys, that changes the set of
possible key sequences.  For example, if you redefine `C-f' as a
prefix, `C-f C-k' automatically becomes a key (complete, unless you
define it too as a prefix).  Conversely, if you remove the prefix
definition of `C-x 4', then `C-x 4 f' (or `C-x 4 ANYTHING') is no
longer a key.

   Typing the help character (`C-h' or <F1>) after a prefix character
displays a list of the commands starting with that prefix.  There are a
few prefix characters for which `C-h' does not work--for historical
reasons, they have other meanings for `C-h' which are not easy to
change.  But <F1> should work for all prefix characters.


File: emacs,  Node: Commands,  Next: Text Characters,  Prev: Keys,  Up: Top

Keys and Commands
=================

   This manual is full of passages that tell you what particular keys
do.  But Emacs does not assign meanings to keys directly.  Instead,
Emacs assigns meanings to named "commands", and then gives keys their
meanings by "binding" them to commands.

   Every command has a name chosen by a programmer.  The name is usually
made of a few English words separated by dashes; for example,
`next-line' or `forward-word'.  A command also has a "function
definition" which is a Lisp program; this is what makes the command do
what it does.  In Emacs Lisp, a command is actually a special kind of
Lisp function; one which specifies how to read arguments for it and
call it interactively.  For more information on commands and functions,
see *Note What Is a Function: (elisp)What Is a Function.  (The
definition we use in this manual is simplified slightly.)

   The bindings between keys and commands are recorded in various tables
called "keymaps".  *Note Keymaps::.

   When we say that "`C-n' moves down vertically one line" we are
glossing over a distinction that is irrelevant in ordinary use but is
vital in understanding how to customize Emacs.  It is the command
`next-line' that is programmed to move down vertically.  `C-n' has this
effect _because_ it is bound to that command.  If you rebind `C-n' to
the command `forward-word' then `C-n' will move forward by words
instead.  Rebinding keys is a common method of customization.

   In the rest of this manual, we usually ignore this subtlety to keep
things simple.  To give the information needed for customization, we
state the name of the command which really does the work in parentheses
after mentioning the key that runs it.  For example, we will say that
"The command `C-n' (`next-line') moves point vertically down," meaning
that `next-line' is a command that moves vertically down and `C-n' is a
key that is standardly bound to it.

   While we are on the subject of information for customization only,
it's a good time to tell you about "variables".  Often the description
of a command will say, "To change this, set the variable `mumble-foo'."
A variable is a name used to remember a value.  Most of the variables
documented in this manual exist just to facilitate customization: some
command or other part of Emacs examines the variable and behaves
differently according to the value that you set.  Until you are
interested in customizing, you can ignore the information about
variables.  When you are ready to be interested, read the basic
information on variables, and then the information on individual
variables will make sense.  *Note Variables::.


File: emacs,  Node: Text Characters,  Next: Entering Emacs,  Prev: Commands,  Up: Top

Character Set for Text
======================

   Text in Emacs buffers is a sequence of 8-bit bytes.  Each byte can
hold a single ASCII character.  Both ASCII control characters (octal
codes 000 through 037, and 0177) and ASCII printing characters (codes
040 through 0176) are allowed; however, non-ASCII control characters
cannot appear in a buffer.  The other modifier flags used in keyboard
input, such as Meta, are not allowed in buffers either.

   Some ASCII control characters serve special purposes in text, and
have special names.  For example, the newline character (octal code
012) is used in the buffer to end a line, and the tab character (octal
code 011) is used for indenting to the next tab stop column (normally
every 8 columns).  *Note Text Display::.

   Non-ASCII printing characters can also appear in buffers.  When
multibyte characters are enabled, you can use any of the non-ASCII
printing characters that Emacs supports.  They have character codes
starting at 256, octal 0400, and each one is represented as a sequence
of two or more bytes.  *Note International::.

   If you disable multibyte characters, then you can use only one
alphabet of non-ASCII characters, but they all fit in one byte.  They
use codes 0200 through 0377.  *Note Single-Byte European Support::.

