xref: /386bsd/usr/local/info/emacs-2 (revision a2142627)

This is Info file ../info/emacs, produced by Makeinfo-1.54 from the
input file emacs.texi.


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.
     675 Mass Ave, Cambridge, MA 02139, 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., 675 Mass Ave, Cambridge, MA 02139, 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: filling of text; automatic indentation of
programs; viewing two or more files at once; 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 have it.  *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.  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.

   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 them, and
edit files at the same time as you run shell commands.


File: emacs,  Node: Screen,  Next: User Input,  Prev: Concept Index,  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 under X you can create additional frames if you wish.  *Note
Frames::.

   When you start Emacs, the entire frame except for the last line is
devoted to the text you are editing.  This area is called "window".
The last line is a special "echo area" or "minibuffer window" where
prompts appear and where you can enter responses.  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.  The other windows display text for reference
only, unless/until you select them.

   Each window's last line is a "mode line" which describes what is
going on in that window.  It is in inverse video if the terminal
supports that, and contains text that starts like `-----Emacs:
SOMETHING'.  Its purpose is to indicate 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.


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".
Other commands move point through the text, so that you can edit at
different places in it.

   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, 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.

   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 screen (below the mode line) is the
"echo area".  It is used to display small amounts of text for several
purposes.

   "Echoing" means printing out 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.

   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,  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.  The mode line is in inverse
video if the terminal supports that, starts and ends with dashes, and
contains text like `Emacs: SOMETHING'.

   If a mode line has something else in place of `Emacs: SOMETHING',
then the window above it is in a special subsystem such as Dired.  The
mode line then indicates the status of the subsystem.

   Normally, the mode line looks like this:

     --CH-Emacs: BUF      (MAJOR MINOR)----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.
Exception: for a read-only buffer, it is `%%'.

   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.

   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, and C mode.  *Note Major Modes::,
for details of how the modes differ and how to select one.

   MINOR is a list of some of the "minor modes" that are turned on at
the moment in the window's chosen buffer.  `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::.

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

   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 and not any one buffer, the square
brackets appear in every window's mode line or not in any of them.
*Note Recursive Edit::.

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


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

Keyboard Input
==============

   GNU Emacs uses an extension of the ASCII character set for keyboard
input.  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 and then pressing `a'.

   Some control characters have special names, and special keys you can
type them with: for example, RET, TAB, LFD, 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.

   On ASCII terminals, the shift key is meaningless with control
characters: `C-a' and `C-A' are the same character, and Emacs cannot
distinguish them.  Under X Windows, these are distinct characters, but
the standard key bindings treat them the same in all contexts.

   On ASCII terminals, there are only 32 possible control characters.
These are the control variants of letters and `@[]\^_'.  Under X
Windows, every non-control character has a control variant.  For
example, `C-+' and `C-5' are meaningful under X.

   Emacs extends the ASCII character code by adding an extra bit to each
character.  The additional bit is called Meta.  Any character can be
made Meta; examples of Meta characters 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 traditional reasons, `M-C-a' is usually called
`C-M-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 keyboard input character.  These are called SUPER, HYPER and ALT.
With them, you can make characters that we denote with `s-', `H-' and
`A-'.  Thus, `s-H-C-x' is short for `Super-Hyper-Control-x'.  Not all X
terminals actually provide keys for these modifier flags, and the
standard key bindings of Emacs do not include such characters.  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.  These inputs do not have numeric
character codes.  Instead, Emacs represents them by their names
(actually, Lisp objects called "symbols").

   Input characters and non-character inputs are collectively called
"input events".

   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 converts them to names 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 combine as part of the invocation of a single command.  Recall
that input events include both keyboard characters and non-character
inputs (function keys, arrow keys, mouse buttons, and so forth).

   If the sequence is enough to invoke a command, it is a "complete
key".  If it isn't long enough to be complete, we call it a "prefix
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'.

   Most single characters constitute complete keys in the standard Emacs
command bindings.  A few of them are prefix keys.  A prefix key can be
followed by additional input characters (or other events) to make a
longer key, which may itself be complete or a prefix.

   For example, `C-x' is a prefix key, so `C-x' and the next input
character 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 any key sequence longer than one character must be
reached through a chain of prefix keys.

   By contrast, 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-x', `C-h', `C-x
C-a', `C-x n', `C-x r', `C-x v', `C-x 4', `C-x 5', and ESC.  But this
is not cast in concrete; it is just a matter of Emacs's standard key
bindings.  In customizing Emacs, you could make new prefix keys, or
eliminate these.  *Note Key Bindings::.

   Whether a sequence is a key can be changed by customization.  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') after a prefix character usually
displays a list of the commands starting with that prefix.  There are a
few prefix characters for which this doesn't work--for historical
reasons, they have other meanings for `C-h' which are not easy to
change.


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 customizer the information he needs, 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 accordingly.  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
======================

   Emacs buffers use an 8-bit character set, because bytes have 8 bits.
ASCII graphic characters in Emacs buffers are displayed with their
graphics.  The newline character (which has the same character code as
LFD) is displayed by starting a new line.  The tab character is
displayed by moving to the next tab stop column (usually every 8
columns).  Other control characters are displayed as a caret (`^')
followed by the non-control version of the character; thus, `C-a' is
displayed as `^A'.

   Non-ASCII characters 128 and up are displayed with octal escape
sequences; thus, character code 243 (octal) is displayed as `\243'.
You can customize the display of these character codes (or ANSI
characters) by creating a "display table"; this is useful for editing
files that use 8-bit European character sets.  *Note Display Tables:
(elisp)Display Tables.


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

Entering and Exiting Emacs
**************************

   The usual way to invoke Emacs is with the shell command `emacs'.
Emacs clears the screen and then displays an initial help message and
copyright notice.  On a window system, Emacs opens a window of its own.
You can begin typing Emacs commands immediately afterward.

   Some operating systems insist on discarding all type-ahead when Emacs
starts up; they give Emacs no way to prevent this.  Therefore, it is
wise to wait until Emacs clears the screen before typing your first
editing command.

   If you run Emacs from a shell window under the X Window System, run
it in the background with `emacs&'.  This way, Emacs does not tie up
the shell window, so you can use it to run other shell commands while
Emacs operates its own X windows.

   When Emacs starts up, it makes a buffer named `*scratch*'.  That's
the buffer you start out in.  The `*scratch*' uses Lisp Interaction
mode; you can use it to type Lisp expressions and evaluate them, or you
can ignore that capability and simply doodle.  (You can specify a
different major mode for this buffer by setting the variable
`initial-major-mode' in your init file.  *Note Init File::.)

   It is also possible to specify files to be visited, Lisp files to be
loaded, and functions to be called, by giving Emacs arguments in the
shell command line.  *Note Command Arguments::.  But we don't recommend
doing this.  The feature exists mainly for compatibility with other
editors.

   Many other editors are designed to be started afresh each time you
want to edit.  You edit one file and then exit the editor.  The next
time you want to edit either another file or the same one, you must run
the editor again.  With these editors, it makes sense to use a command
line argument to say which file to edit.

   But starting a new Emacs each time you want to edit a different file
does not make sense.  For one thing, this would be annoyingly slow.  For
another, this would fail to take advantage of Emacs's ability to visit
more than one file in a single editing session.

   The recommended way to use GNU Emacs is to start it only once, just
after you log in, and do all your editing in the same Emacs session.
Each time you want to edit a different file, you visit it with the
existing Emacs, which eventually comes to have many files in it ready
for editing.  Usually you do not kill the Emacs until you are about to
log out.


File: emacs,  Node: Exiting,  Next: Basic,  Prev: Entering Emacs,  Up: Top

Exiting Emacs
=============

   There are two commands for exiting Emacs because there are two kinds
of exiting: "suspending" Emacs and "killing" Emacs.

   "Suspending" means stopping Emacs temporarily and returning control
to its parent process (usually a shell), allowing you to resume editing
later in the same Emacs job, with the same files, same kill ring, same
undo history, and so on.  This is the usual way to exit.

   "Killing" Emacs means destroying the Emacs job.  You can run Emacs
again later, but you will get a fresh Emacs; there is no way to resume
the same editing session after it has been killed.

`C-z'
     Suspend Emacs (`suspend-emacs').

`C-x C-c'
     Kill Emacs (`save-buffers-kill-emacs').

   To suspend Emacs, type `C-z' (`suspend-emacs').  This takes you back
to the shell from which you invoked Emacs.  You can resume Emacs with
the shell command `%emacs' in most common shells.

   On systems that do not permit programs to be suspended, `C-z' runs
an inferior shell that communicates directly with the terminal, and
Emacs waits until you exit the subshell.  (The way to do that is
probably with `C-d' or `exit', but it depends on which shell you use.)
The only way on these systems to get back to the shell from which Emacs
was run (to log out, for example) is to kill Emacs.

   Suspending also fails if you run Emacs under a shell that doesn't
support suspending programs, even if the system itself does support it.
In such a case, you can set the variable `cannot-suspend' to a
non-`nil' value to force `C-z' to run an inferior shell.  (One might
also describe Emacs's parent shell as "inferior" for failing to support
job control properly, but that is a matter of taste.)

   When Emacs communicates directly with an X server and creates its own
dedicated X windows, `C-z' has a different meaning.  Suspending an
applications that uses its own X windows is not meaningful or useful.
Instead, `C-z' runs the command `iconify-frame', which temporarily
closes up the selected Emacs frame.  The way to get back to a shell
window is with the window manager.

   To kill Emacs, type `C-x C-c' (`save-buffers-kill-emacs').  A
two-character key is used for this to make it harder to type.  Unless a
numeric argument is used, this command first offers to save any modified
file-visiting buffers.  If you do not save them all, it asks for
reconfirmation with `yes' before killing Emacs, since any changes not
saved will be lost forever.  Also, if any subprocesses are still
running, `C-x C-c' asks for confirmation about them, since killing
Emacs will kill the subprocesses immediately.

   The operating system usually listens for certain special characters
whose meaning is to kill or suspend the program you are running.  This
operating system feature is turned off while you are in Emacs.  The
meanings of `C-z' and `C-x C-c' as keys in Emacs were inspired by the
use of `C-z' and `C-c' on several operating systems as the characters
for stopping or killing a program, but that is their only relationship
with the operating system.  You can customize these keys to run any
commands (*note Keymaps::.).


File: emacs,  Node: Basic,  Next: Undo,  Prev: Exiting,  Up: Top

Basic Editing Commands
**********************

   We now give the basics of how to enter text, make corrections, and
save the text in a file.  If this material is new to you, you might
learn it more easily by running the Emacs learn-by-doing tutorial.  To
start the tutorial, type `Control-h t' (`help-with-tutorial').

   To clear the screen and redisplay, type `C-l' (`recenter').

* Menu:

* Inserting Text::     Inserting text by simply typing it.
* Moving Point::       How to move the cursor to the place where you want to
		         change something.
* Erasing::	       Deleting and killing text.
* Files: Basic Files.  Visiting, creating, and saving files.
* Help: Basic Help.    Asking what a character does.
* Blank Lines::        Commands to make or delete blank lines.
* Continuation Lines:: Lines too wide for the screen.
* Position Info::      What page, line, row, or column is point on?
* Arguments::	       Numeric arguments for repeating a command.