? commands+entering.texi.patch
? emacs+screen+commands+entering.texi.patch
? emacs+screen.texi.patch
Index: commands.texi
===================================================================
RCS file: /sources/emacs/emacs/man/commands.texi,v
retrieving revision 1.22
diff -c -r1.22 commands.texi
*** commands.texi	8 Feb 2006 02:25:09 -0000	1.22
--- commands.texi	19 Apr 2006 17:55:42 -0000
***************
*** 6,14 ****
  @chapter Characters, Keys and Commands
  
    This chapter explains the character sets used by Emacs for input
! commands and for the contents of files, and also explains the concepts
! of @dfn{keys} and @dfn{commands}, which are fundamental for understanding
! how Emacs interprets your keyboard and mouse input.
  @end iftex
  
  @ifnottex
--- 6,14 ----
  @chapter Characters, Keys and Commands
  
    This chapter explains the character sets used by Emacs for input
! commands and for the contents of files and the fundamental concepts of
! @dfn{keys} and @dfn{commands}, whereby Emacs interprets your keyboard
! and mouse input.
  @end iftex
  
  @ifnottex
***************
*** 35,45 ****
  for short).  @kbd{C-a} gets its name from the fact that you type it by
  holding down the @key{CTRL} key while pressing @kbd{a}.
  
!   Some @acronym{ASCII} control characters have special names, and most terminals
! have special keys you can type them with: for example, @key{RET},
! @key{TAB}, @key{DEL} and @key{ESC}.  The space character is usually
! referred to below as @key{SPC}, even though strictly speaking it is a
! graphic character whose graphic happens to be blank.
  
    Emacs extends the @acronym{ASCII} character set with thousands more printing
  characters (@pxref{International}), additional control characters, and a
--- 35,45 ----
  for short).  @kbd{C-a} gets its name from the fact that you type it by
  holding down the @key{CTRL} key while pressing @kbd{a}.
  
!   Some @acronym{ASCII} control characters have special names, and most
! terminals have special keys you can type them with: for example,
! @key{RET}, @key{TAB}, @key{DEL} and @key{ESC}.  The space character is
! usually known as @key{SPC}, even though strictly speaking it is a
! blank graphic character.
  
    Emacs extends the @acronym{ASCII} character set with thousands more printing
  characters (@pxref{International}), additional control characters, and a
***************
*** 51,59 ****
  @kbd{C-a} and @kbd{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 @kbd{C-a} and
! @kbd{C-A}.  Graphical terminals make it possible to enter all these
  characters.  For example, @kbd{C--} (that's Control-Minus) and
  @kbd{C-5} are meaningful Emacs commands on a graphical terminal.
  
--- 51,59 ----
  @kbd{C-a} and @kbd{C-A} are the same character, and Emacs cannot
  distinguish them.
  
!   The Emacs character set has room for control variants of all
! printing characters, and knows @kbd{C-a} and @kbd{C-A} are not the
! same.  Graphical terminals make it possible to enter all these
  characters.  For example, @kbd{C--} (that's Control-Minus) and
  @kbd{C-5} are meaningful Emacs commands on a graphical terminal.
  
***************
*** 106,115 ****
  because the first one goes to work on the @kbd{C-x}.)
  
    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.  However, you can modify these events
! with the modifier keys @key{CTRL}, @key{META}, @key{SUPER},
! @key{HYPER} and @key{ALT}, just as you can modify keyboard characters.
  
  @cindex input event
    Input characters and non-character inputs are collectively called
--- 106,115 ----
  because the first one goes to work on the @kbd{C-x}.)
  
    Keyboard input includes keyboard keys that are not characters at
! all, such as function keys and arrow keys.  Mouse buttons are also not
! characters.  However, you can modify these events with the modifier
! keys @key{CTRL}, @key{META}, @key{SUPER}, @key{HYPER} and @key{ALT},
! just as you can modify keyboard characters.
  
  @cindex input event
    Input characters and non-character inputs are collectively called
***************
*** 121,127 ****
    @acronym{ASCII} terminals cannot really send anything to the computer except
  @acronym{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.
  
--- 121,127 ----
    @acronym{ASCII} terminals cannot really send anything to the computer except
  @acronym{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 catch these special sequences
  and convert them to function key events before any other part of Emacs
  gets to see them.
  
***************
*** 130,141 ****
  
  @cindex key sequence
  @cindex key
!   A @dfn{key sequence} (@dfn{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 @kbd{C-f} is enough to move forward one character in the
! buffer.  But Emacs also has commands that take two or more events to
! invoke.
  
  @cindex complete key
  @cindex prefix key
--- 130,140 ----
  
  @cindex key sequence
  @cindex key
!   A @dfn{key sequence} (@dfn{key}, for short) is a meaningful sequence
! of input events---a ``single command.''  Some Emacs command sequences
! are invoked by just one character or one event; for example, just
! @kbd{C-f} moves forward one character in the buffer.  But Emacs also
! has commands that take two or more events to invoke.
  
  @cindex complete key
  @cindex prefix key
***************
*** 158,190 ****
  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-event sequence @kbd{C-f C-k} is not a key, because
! the @kbd{C-f} is a complete key in itself.  It's impossible to give
! @kbd{C-f C-k} an independent meaning as a command.  @kbd{C-f C-k} is two
! key sequences, not address@hidden
  
    All told, the prefix keys in Emacs are @kbd{C-c}, @kbd{C-h},
  @kbd{C-x}, @kbd{C-x @key{RET}}, @kbd{C-x @@}, @kbd{C-x a}, @kbd{C-x
  n}, @address@hidden r}}, @kbd{C-x v}, @kbd{C-x 4}, @kbd{C-x 5}, @kbd{C-x
  6}, @key{ESC}, @kbd{M-g}, and @kbd{M-o}.  (@key{F1} and @key{F2} are
! aliases for @kbd{C-h} and @kbd{C-x 6}.)  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 some
! of the standard ones.  @xref{Key Bindings}.
  
!   If you do make or eliminate prefix keys, that changes the set of
  possible key sequences.  For example, if you redefine @kbd{C-f} as a
! prefix, @kbd{C-f C-k} automatically becomes a key (complete, unless you
! define that too as a prefix).  Conversely, if you remove the prefix
! definition of @kbd{C-x 4}, then @kbd{C-x 4 f} (or @kbd{C-x 4
! @var{anything}}) is no longer a key.
  
    Typing the help character (@kbd{C-h} or @key{F1}) after a prefix key
  displays a list of the commands starting with that prefix.  There are
  a few prefix keys for which @kbd{C-h} does not work---for historical
  reasons, they define other meanings for @kbd{C-h} which are painful to
! change.  But @key{F1} should work for all prefix keys.
  
  @node Commands, Text Characters, Keys, Top
  @section Keys and Commands
--- 157,189 ----
  sequences.  There's no limit to the length of a key sequence, but in
  practice people rarely use sequences longer than four events.
  
!   You can't add input events onto a complete key.  For example, the
! two-event sequence @kbd{C-f C-k} is not a key, because the @kbd{C-f}
! is a complete key in itself.  It's impossible to give @kbd{C-f C-k} an
! independent meaning as a command.  @kbd{C-f C-k} is two key sequences,
! not address@hidden
  
    All told, the prefix keys in Emacs are @kbd{C-c}, @kbd{C-h},
  @kbd{C-x}, @kbd{C-x @key{RET}}, @kbd{C-x @@}, @kbd{C-x a}, @kbd{C-x
  n}, @address@hidden r}}, @kbd{C-x v}, @kbd{C-x 4}, @kbd{C-x 5}, @kbd{C-x
  6}, @key{ESC}, @kbd{M-g}, and @kbd{M-o}.  (@key{F1} and @key{F2} are
! aliases for @kbd{C-h} and @kbd{C-x 6}.)  This list is only due to
! Emacs's standard key bindings.  If you customize Emacs, you can make
! new prefix keys, or eliminate some of the standard ones (not
! recommended for most users).  @xref{Key Bindings}.
  
!   If you make or eliminate prefix keys, that changes the set of
  possible key sequences.  For example, if you redefine @kbd{C-f} as a
! prefix, @kbd{C-f C-k} automatically becomes a key (complete, unless
! you define that too as a prefix).  Conversely, if you remove the
! prefix definition of @kbd{C-x 4}, then @kbd{C-x 4 f} and @kbd{C-x 4
! @var{anything}} are no longer keys.
  
    Typing the help character (@kbd{C-h} or @key{F1}) after a prefix key
  displays a list of the commands starting with that prefix.  There are
  a few prefix keys for which @kbd{C-h} does not work---for historical
  reasons, they define other meanings for @kbd{C-h} which are painful to
! change.  @key{F1} works for all prefix keys.
  
  @node Commands, Text Characters, Keys, Top
  @section Keys and Commands
***************
*** 197,257 ****
  Emacs assigns meanings to named @dfn{commands}, and then gives keys
  their meanings by @dfn{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,
  @code{next-line} or @code{forward-word}.  A command also has a
! @dfn{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 @ref{What Is a Function,, What Is a Function, elisp, The
! Emacs Lisp Reference Manual}.  (The definition we use in this manual is
! simplified slightly.)
  
!   The bindings between keys and commands are recorded in various tables
! called @dfn{keymaps}.  @xref{Keymaps}.
  
    When we say that address@hidden 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
! @code{next-line} that is programmed to move down vertically.  @kbd{C-n} has
! this effect @emph{because} it is bound to that command.  If you rebind
! @kbd{C-n} to the command @code{forward-word} then @kbd{C-n} will move
! forward by words instead.  Rebinding keys is a common method of
  address@hidden
  
    In the rest of this manual, we usually ignore this distinction to
  keep things simple.  We will often speak of keys like @kbd{C-n} as
! commands, even though strictly speaking a key is bound to some
! command.  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 @kbd{C-n} (@code{next-line}) moves point vertically
! down,'' meaning that @code{next-line} is a command that moves
! vertically down, and @kbd{C-n} is a key that is normally bound to it.
  
!   While we are on the subject of information for customization only,
! it's a good time to tell you about @dfn{variables}.  Often the
! description of a command will say, ``To change this, set the variable
! @code{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.  @xref{Variables}.
  
  @node Text Characters, Entering Emacs, Commands, Top
  @section Character Set for Text
  @cindex characters (in text)
  
!   Text in Emacs buffers is a sequence of 8-bit bytes.  Each byte can
! hold a single @acronym{ASCII} character.  Both @acronym{ASCII} control characters (octal
! codes 000 through 037, and 0177) and @acronym{ASCII} printing characters (codes
! 040 through 0176) are allowed; however, address@hidden 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 @acronym{ASCII} control characters serve special purposes in text, and have
  special names.  For example, the newline character (octal code 012) is
--- 196,255 ----
  Emacs assigns meanings to named @dfn{commands}, and then gives keys
  their meanings by @dfn{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,
  @code{next-line} or @code{forward-word}.  A command also has a
! @dfn{function definition} which is a Lisp program; this is how the
! command does work.  In Emacs Lisp, a command is a Lisp function with
! special options to read arguments and for interactive use.  For more
! information on commands and functions, see @ref{What Is a Function,,
! What Is a Function, elisp, The Emacs Lisp Reference Manual}.  (The
! definition here is simplified slightly.)
  
!   The bindings between keys and commands are recorded in tables called
! @dfn{keymaps}.  @xref{Keymaps}.
  
    When we say that address@hidden moves down vertically one line'' we are
! glossing over a minor distinction that is irrelevant in ordinary use
! but is vital to Emacs customization.  The command @code{next-line}
! does a vertical move downward.  @kbd{C-n} has this effect
! @emph{because} it is bound to @code{next-line}.  If you rebind
! @kbd{C-n} to the command @code{forward-word}, then @kbd{C-n} will move
! forward one word instead.  Rebinding keys is common in
  address@hidden
  
    In the rest of this manual, we usually ignore this distinction to
  keep things simple.  We will often speak of keys like @kbd{C-n} as
! commands, even though the key is bound to a command.  Usually 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 @kbd{C-n} (@code{next-line}) moves point vertically
! down,'' meaning that the command @code{next-line} moves vertically
! down, and @kbd{C-n} is a key that is normally bound to it.
  
!   Since we are discussing customization, you should know about
! @dfn{variables}.  Often the description of a command will say, ``To
! change this, set the variable @code{mumble-foo}.''  A variable is a
! name used to store a value.  Most of the variables documented in this
! manual are meant for customization: some command or other part of
! Emacs examines the variable and behaves differently according to the
! value that you set.  You can ignore the information about variables
! until you want to customize them.  When you are ready, read the basic
! information on variables, and then customizing individual variables
! will make sense.  @xref{Variables}.
  
  @node Text Characters, Entering Emacs, Commands, Top
  @section Character Set for Text
  @cindex characters (in text)
  
!   Text in Emacs buffers is a sequence of characters.  In the default
! Unibyte Mode, each character in an 8-bit byte that can hold a single
! @acronym{ASCII} character.  Both @acronym{ASCII} control characters
! (octal codes 000 through 037, and 0177) and @acronym{ASCII} printing
! characters (codes 040 through 0176) are allowed; however,
! address@hidden 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 @acronym{ASCII} control characters serve special purposes in text, and have
  special names.  For example, the newline character (octal code 012) is
***************
*** 267,274 ****
  with codes 128 through 255 can also appear in multibyte buffers.
  
    If you disable multibyte characters, then you can use only one
! alphabet of address@hidden characters, but they all fit in one byte.  They
! use codes 0200 through 0377.  @xref{Unibyte Mode}.
  
  @ifnottex
  @lowersections
--- 265,272 ----
  with codes 128 through 255 can also appear in multibyte buffers.
  
    If you disable multibyte characters, then you can use only one
! alphabet of address@hidden characters, which all fit in one byte.
! They use octal codes 0200 through 0377.  @xref{Unibyte Mode}.
  
  @ifnottex
  @lowersections
Index: emacs.texi
===================================================================
RCS file: /sources/emacs/emacs/man/emacs.texi,v
retrieving revision 1.126
diff -c -r1.126 emacs.texi
*** emacs.texi	12 Apr 2006 00:27:50 -0000	1.126
--- emacs.texi	19 Apr 2006 17:55:42 -0000
***************
*** 89,97 ****
  @value{EMACSVER}.
  
  @ifinfo
! If you never before used the Info documentation system, type @kbd{h},
! and Emacs will take you to a programmed instruction sequence for the
! Info commands.
  @end ifinfo
  
  For information on extending Emacs, see @ref{Top, Emacs Lisp,, elisp, The
--- 89,97 ----
  @value{EMACSVER}.
  
  @ifinfo
! To learn more about the Info documentation system, type @kbd{h}, and
! Emacs will take you to a programmed instruction sequence for the Info
! commands.
  @end ifinfo
  
  For information on extending Emacs, see @ref{Top, Emacs Lisp,, elisp, The
***************
*** 867,913 ****
  @unnumbered Preface
  
    This manual documents the use and simple customization of the Emacs
! editor.  The reader is not expected to be a programmer; simple
! customizations do not require programming skill.  The user who is not
! interested in customizing can ignore the scattered customization hints.
  
    This is primarily a reference manual, but can also be used as a
! primer.  For complete beginners, it is a good idea to start with the
! on-line, learn-by-doing tutorial, before reading the manual.  To run the
! tutorial, start Emacs and type @kbd{C-h t}.  This way you can learn
! Emacs by using Emacs on a specially designed file which describes
! commands, tells you when to try them, and then explains the results you
! see.
  
    On first reading, just skim chapters 1 and 2, which describe the
  notational conventions of the manual and the general appearance of the
  Emacs display screen.  Note which questions are answered in these
  chapters, so you can refer back later.  After reading chapter 4, you
! should practice the commands there.  The next few chapters describe
! fundamental techniques and concepts that are used constantly.  You need
! to understand them thoroughly, experimenting with them if necessary.
  
    Chapters 14 through 19 describe intermediate-level features that are
! useful for all kinds of editing.  Chapter 20 and following chapters
! describe features that you may or may not want to use; read those
! chapters when you need them.
  
    Read the Trouble chapter if Emacs does not seem to be working
! properly.  It explains how to cope with some common problems
  (@pxref{Lossage}), as well as when and how to report Emacs bugs
  (@pxref{Bugs}).
  
!   To find the documentation on a particular command, look in the index.
! Keys (character commands) and command names have separate indexes.  There
! is also a glossary, with a cross reference for each term.
  
    This manual is available as a printed book and also as an Info file.
! The Info file is for on-line perusal with the Info program, which will
! be the principal way of viewing documentation on-line in the GNU system.
! Both the Info file and the Info program itself are distributed along
! with GNU Emacs.  The Info file and the printed book contain
  substantially the same text and are generated from the same source
! files, which are also distributed along with GNU Emacs.
  
    GNU Emacs is a member of the Emacs editor family.  There are many
  Emacs editors, all sharing common principles of organization.  For
--- 867,912 ----
  @unnumbered Preface
  
    This manual documents the use and simple customization of the Emacs
! editor.  Simple Emacs customizations do not require you to be a
! programmer.  If you are not interested in customizing, you can ignore
! the scattered customization hints.
  
    This is primarily a reference manual, but can also be used as a
! primer.  You should start with the on-line, learn-by-doing tutorial,
! before reading the manual if you are just starting to use Emacs.  To
! run the tutorial, start Emacs and type @kbd{C-h t}.  The tutorial
! describes commands, tells you when to try them, and explains the
! results.
  
    On first reading, just skim chapters 1 and 2, which describe the
  notational conventions of the manual and the general appearance of the
  Emacs display screen.  Note which questions are answered in these
  chapters, so you can refer back later.  After reading chapter 4, you
! should practice the commands shown there.  The next few chapters
! describe fundamental techniques and concepts that are used constantly.
! You need to understand them thoroughly and experiment with them.
  
    Chapters 14 through 19 describe intermediate-level features that are
! useful for many kinds of editing.  Chapter 20 and following chapters
! describe optional yet useful features; read those chapters when you
! need them.
  
    Read the Trouble chapter if Emacs does not seem to be working
! properly.  It explains how to cope with many common problems
  (@pxref{Lossage}), as well as when and how to report Emacs bugs
  (@pxref{Bugs}).
  
!   To find out more about a particular command, look in the index.
! Keys (character commands) and command names have separate indexes.
! There is also a glossary, with a cross reference for each term.
  
    This manual is available as a printed book and also as an Info file.
! The Info file is for on-line perusal with the Info program, which is
! the principal way to access documentation on-line in the GNU system.
! Both the Emacs Info file and the Info program itself are distributed
! along with GNU Emacs.  The Info file and the printed book contain
  substantially the same text and are generated from the same source
! files, which are also distributed with GNU Emacs.
  
    GNU Emacs is a member of the Emacs editor family.  There are many
  Emacs editors, all sharing common principles of organization.  For
***************
*** 1062,1116 ****
  self-documenting, customizable, extensible real-time display editor Emacs.
  (The `G' in `GNU' is not silent.)
  
!   We say that Emacs is a @dfn{display} editor because normally the text
! being edited is visible on the screen and is updated automatically as you
  type your commands.  @xref{Screen,Display}.
  
!   We call it a @dfn{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.  @xref{Basic,Real-time,Basic Editing}.
  
!   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.
  
    @dfn{Self-documenting} means that at any time you can type a special
  character, @kbd{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.  @xref{Help}.
  
!   @dfn{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 @samp{<**} and end with @samp{**>}, you can tell
! the Emacs comment manipulation commands to use those strings
! (@pxref{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.  @xref{Customization}.
! 
!   @dfn{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; 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.  @xref{Top,
! Emacs Lisp Intro, Preface, eintr, An Introduction to Programming in
! Emacs Lisp}, if you want to learn Emacs Lisp programming.
  
     When running on a graphical display, Emacs provides its own menus
! and convenient handling of mouse buttons.  But Emacs provides many of
! the benefits of a graphical display even on a text-only terminal.  For
! instance, it can highlight parts of a file, display and edit several
! files at once, move text between files, and edit files while running
! shell commands.
  
  @include screen.texi
  @include commands.texi
--- 1061,1116 ----
  self-documenting, customizable, extensible real-time display editor Emacs.
  (The `G' in `GNU' is not silent.)
  
!   Emacs is a @dfn{display} editor because normally the text being
! edited is visible on the screen and is updated automatically as you
  type your commands.  @xref{Screen,Display}.
  
!   It is a @dfn{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.  @xref{Basic,Real-time,Basic Editing}.
  
!   Emacs is advanced because it provides much more than simple
! insertion and deletion.  It can control subprocesses, indent programs
! automatically, show two or more files at once, and edit formatted
! text.  Emacs can operate in terms of characters, words, lines,
! sentences, paragraphs, and pages, as well as expressions and comments
! in several different programming languages.
  
    @dfn{Self-documenting} means that at any time you can type a special
  character, @kbd{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.  @xref{Help}.
  
!   @dfn{Customizable} means that you can affect or redefine Emacs
! commands in little ways.  For example, if you use a programming
! language in which comments start with @samp{<**} and end with
! @samp{**>}, you can tell the Emacs comment manipulation commands to
! use those strings (@pxref{Comments}).  Another sort of customization
! is rearrangement of the command set.  For example, you can rebind the
! basic cursor motion commands (up, down, left and right) to any keys on
! the keyboard that you find comfortable.  @xref{Customization}.
! 
!   @dfn{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; the few exceptions
! could have been written in Lisp but use C instead for efficiency.
! Although only a programmer can write an extension, anybody can use it
! afterwards.  @xref{Top, Emacs Lisp Intro, Preface, eintr, An
! Introduction to Programming in Emacs Lisp}, if you want to learn Emacs
! Lisp programming.
  
     When running on a graphical display, Emacs provides its own menus
! and convenient handling of mouse buttons.  In addition, Emacs provides
! many of the benefits of a graphical display even on a text-only
! terminal.  For instance, it can highlight parts of a file, display and
! edit several files at once, move text between files, and edit files
! while running shell commands.
  
  @include screen.texi
  @include commands.texi
Index: entering.texi
===================================================================
RCS file: /sources/emacs/emacs/man/entering.texi,v
retrieving revision 1.16
diff -c -r1.16 entering.texi
*** entering.texi	5 Feb 2006 22:41:30 -0000	1.16
--- entering.texi	19 Apr 2006 17:55:42 -0000
***************
*** 8,65 ****
  @cindex starting Emacs
  
    The usual way to invoke Emacs is with the shell command
! @command{emacs}.  Emacs clears the screen and then displays an initial
! help message and copyright notice.  Some operating systems discard all
! type-ahead when Emacs starts up; they give Emacs no way to prevent
! this.  If you ever use those systems, learn the habit of waiting for
! Emacs to clear 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 @command{emacs&}.  This way, Emacs does not tie up
! the shell window, so you can use that to run other shell commands while
! Emacs operates its own X windows.  You can begin typing Emacs commands
! as soon as you direct your keyboard input to the Emacs frame.
  
  @vindex initial-major-mode
    When Emacs starts up, it creates a buffer named @samp{*scratch*}.
! That's the buffer you start out in.  The @samp{*scratch*} buffer uses
! Lisp Interaction mode; you can use it to type Lisp expressions and
! evaluate them, or you can ignore that capability and just write notes
! in it.  (You can specify a different major mode for this buffer by
  setting the variable @code{initial-major-mode} in your init file.
! @xref{Init File}.)
  
    It is 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.  @xref{Emacs Invocation}.  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.  This would fail to take advantage of Emacs's
! ability to visit more than one file in a single editing session, and
! it would lose the other accumulated context, such as the kill ring,
! registers, undo history, and mark ring, that are useful for operating
! on multiple files or even one.
  
    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.  @xref{Files}, for more information on visiting more than one
! file.
! 
!   If you want to edit a file from another program and already have
! Emacs running, you can use the @command{emacsclient} program to open a
! file in the already running Emacs.  @xref{Emacs Server}, for more
! information on editing files with Emacs from other programs.
  
  @ifnottex
  @raisesections
--- 8,60 ----
  @cindex starting Emacs
  
    The usual way to invoke Emacs is with the shell command
! @command{emacs}.  Emacs clears the screen and displays an initial help
! message and copyright notice.  Some operating systems discard all your
! input while Emacs starts up; they give Emacs no way to prevent this.
! If you ever use those systems, wait for Emacs to clear the screen
! before you start typing.
! 
!   From a shell window under the X Window System, run Emacs in the
! background with @command{emacs&}.  This way, Emacs won't tie up the
! shell window, so you can use it to run other shell commands while
! Emacs is running.  You can type Emacs commands as soon as you direct
! your keyboard input to an Emacs frame.
  
  @vindex initial-major-mode
    When Emacs starts up, it creates a buffer named @samp{*scratch*}.
! That's the first buffer you'll see.  The @samp{*scratch*} buffer uses
! Lisp Interaction mode; that lets you type Lisp expressions and
! evaluate them.  You can ignore that capability and just write notes
! there.  You can specify a different major mode for this buffer by
  setting the variable @code{initial-major-mode} in your init file.
! @xref{Init File}.
  
    It is possible to specify files to be visited, Lisp files to be
! loaded, and functions to be called through Emacs command-line
! arguments.  @xref{Emacs Invocation}.  The feature exists mainly for
! compatibility with other editors, and is normally not recommended.
! 
!   Many other editors are designed so you edit one file and then exit
! the editor.  The next time you want to edit a file, you must run the
! editor again.  With these editors, it makes sense to use a
  command-line argument to say which file to edit.
  
!   It's not smart to start a new Emacs for every edited file.  Emacs
! can visit more than one file in a single editing session, and upon
! exit Emacs loses valuable accumulated context, such as the kill ring,
! registers, undo history, and mark ring.  These features are useful for
! operating on multiple files or even one.
  
    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.
! To edit a different file, you visit it with the existing Emacs, which
! eventually will have many files in it ready for editing.  Usually you
! do not kill Emacs until you are about to log out.  @xref{Files}, for
! more information on visiting more than one file.
! 
!   To edit a file from another program while Emacs is running, you can
! use the @command{emacsclient} helper program to open a file in the
! already running Emacs.  @xref{Emacs Server}.
  
  @ifnottex
  @raisesections
***************
*** 73,79 ****
  @cindex leaving Emacs
  @cindex quitting Emacs
  
!   There are two commands for exiting Emacs because there are three
  kinds of exiting: @dfn{suspending} Emacs, @dfn{Iconifying} Emacs, and
  @dfn{killing} Emacs.
  
--- 68,74 ----
  @cindex leaving Emacs
  @cindex quitting Emacs
  
!   There are two commands for exiting Emacs and three
  kinds of exiting: @dfn{suspending} Emacs, @dfn{Iconifying} Emacs, and
  @dfn{killing} Emacs.
  
***************
*** 110,120 ****
  Emacs.  You can resume Emacs with the shell command @command{%emacs}
  in most common shells.  On systems that don't support suspending
  programs, @kbd{C-z} starts 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 @kbd{C-d} or @command{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 can fail if you run Emacs under a shell that doesn't
  support suspending programs, even if the system itself does support
--- 105,115 ----
  Emacs.  You can resume Emacs with the shell command @command{%emacs}
  in most common shells.  On systems that don't support suspending
  programs, @kbd{C-z} starts 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 @kbd{C-d} or
! @command{exit}, but it depends on which shell you use.)  On these
! systems, you can only get back to the shell from which Emacs was run
! (to log out, for example) when you kill Emacs.
  
    Suspending can fail if you run Emacs under a shell that doesn't
  support suspending programs, even if the system itself does support
***************
*** 133,145 ****
  @kindex C-x C-c
  @findex save-buffers-kill-emacs
    To exit and kill Emacs, type @kbd{C-x C-c}
! (@code{save-buffers-kill-emacs}).  A two-character key is used for
! this to make it harder to type by accident.  This command first offers
! to save any modified file-visiting buffers.  If you do not save them
! all, it asks for reconfirmation with @kbd{yes} before killing Emacs,
! since any changes not saved will be lost forever.  Also, if any
! subprocesses are still running, @kbd{C-x C-c} asks for confirmation
! about them, since killing Emacs will also kill the subprocesses.
  
  @vindex confirm-kill-emacs
    If the value of the variable @code{confirm-kill-emacs} is
--- 128,140 ----
  @kindex C-x C-c
  @findex save-buffers-kill-emacs
    To exit and kill Emacs, type @kbd{C-x C-c}
! (@code{save-buffers-kill-emacs}).  A two-character key is used to make
! it harder to type by accident.  This command first offers to save any
! modified file-visiting buffers.  If you do not save them all, it asks
! for confirmation with @kbd{yes} before killing Emacs, since any
! unsaved changes will be lost forever.  Also, if any subprocesses are
! still running, @kbd{C-x C-c} asks for confirmation about them, since
! killing Emacs will also kill the subprocesses.
  
  @vindex confirm-kill-emacs
    If the value of the variable @code{confirm-kill-emacs} is
***************
*** 150,160 ****
  function @code{yes-or-no-p}.  The default value of
  @code{confirm-kill-emacs} is @code{nil}.
  
!   There is no way to resume an Emacs session once you have killed it.
! You can, however, arrange for Emacs to record certain session
! information when you kill it, such as which files are visited, so that
! the next time you start Emacs it will try to visit the same files and
! so on.  @xref{Saving Emacs Sessions}.
  
    The operating system usually listens for certain special characters
  whose meaning is to kill or suspend the program you are running.
--- 145,154 ----
  function @code{yes-or-no-p}.  The default value of
  @code{confirm-kill-emacs} is @code{nil}.
  
!   You can't resume an Emacs session after Emacs is killed.  Emacs can,
! however, record certain session information when you kill it, such as
! which files you visited, so the next time you start Emacs it will try
! to visit the same files.  @xref{Saving Emacs Sessions}.
  
    The operating system usually listens for certain special characters
  whose meaning is to kill or suspend the program you are running.
Index: screen.texi
===================================================================
RCS file: /sources/emacs/emacs/man/screen.texi,v
retrieving revision 1.26
diff -c -r1.26 screen.texi
*** screen.texi	5 Feb 2006 22:41:31 -0000	1.26
--- screen.texi	19 Apr 2006 17:55:42 -0000
***************
*** 24,31 ****
  you click on them.  Below this, the window begins, often with a
  @dfn{scroll bar} on one side.  Below the window comes the last line of
  the frame, a special @dfn{echo area} or @dfn{minibuffer window}, where
! prompts appear and where you enter information when Emacs asks for it.
! See following sections for more information about these special lines.
  
    You can subdivide the window horizontally or vertically to make
  multiple text windows, each of which can independently display some
--- 24,31 ----
  you click on them.  Below this, the window begins, often with a
  @dfn{scroll bar} on one side.  Below the window comes the last line of
  the frame, a special @dfn{echo area} or @dfn{minibuffer window}, where
! prompts appear and you enter information when Emacs asks for it.  See
! following sections for more information about these special lines.
  
    You can subdivide the window horizontally or vertically to make
  multiple text windows, each of which can independently display some
***************
*** 36,55 ****
    At any time, one window is the @dfn{selected window}.  On graphical
  terminals, the selected window normally shows a more prominent cursor
  (usually solid and blinking) while other windows show a weaker cursor
! (such as a hollow box).  On text terminals, which have just one
! cursor, that cursor always appears in the selected window.
  
    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 text in other windows is
! mostly visible for reference, unless/until you select them.  If you
! use multiple frames on a graphical display, then giving the input
! focus to a particular frame selects a window in that frame.
  
    Each window's last line is a @dfn{mode line}, which describes what
! is going on in that window.  It appears in different color and/or a
! ``3D'' box, if the terminal supports that; its contents normally begin
! with @address@hidden:-- @ *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.
--- 36,55 ----
    At any time, one window is the @dfn{selected window}.  On graphical
  terminals, the selected window normally shows a more prominent cursor
  (usually solid and blinking) while other windows show a weaker cursor
! (such as a hollow box).  On text terminals, the cursor always appears
! in the selected window.
  
    Most Emacs commands implicitly apply to the text in the selected
! window (mouse commands generally operate on whatever window you click
! them in, whether selected or not).  The text in unselected windows is
! mostly visible for reference.  If you use multiple frames on a
! graphical display, then giving the input focus to a particular frame
! selects a window in that frame.
  
    Each window's last line is a @dfn{mode line}, which describes what
! is going on in that window.  It appears in different color or a ``3D''
! box if the terminal supports either; its contents normally begin with
! @address@hidden:-- @ *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.
***************
*** 89,104 ****
  currently displayed remembers its point location in case you display
  it again later.  When Emacs displays multiple windows, each window has
  its own point location.  If the same buffer appears in more than one
! window, each window has its own position for point in that buffer, and
! (when possible) its own cursor.
  
!   A text-only terminal has just one cursor, so Emacs puts it
! in the selected window.  The other windows do not show a cursor, even
! though they do have a location of point.  When Emacs updates the
! screen on a text-only terminal, it has to put the cursor temporarily
! at the place the output goes.  This doesn't mean point is there,
! though.  Once display updating finishes, Emacs puts the cursor where
! point is.
  
    On graphical terminals, Emacs shows a cursor in each window; the
  selected window's cursor is solid and blinking, and the other cursors
--- 89,103 ----
  currently displayed remembers its point location in case you display
  it again later.  When Emacs displays multiple windows, each window has
  its own point location.  If the same buffer appears in more than one
! window, each window has its own point in that buffer, and (when
! possible) its own cursor.
  
!   A text-only terminal has just one cursor in the selected window.
! The other windows do not show a cursor, even though they do have a
! location of point.  When Emacs updates the screen on a text-only
! terminal, it has to put the cursor temporarily at the place the output
! goes.  This doesn't mean point is there, though.  Once display
! updating finishes, Emacs puts the cursor where point is.
  
    On graphical terminals, Emacs shows a cursor in each window; the
  selected window's cursor is solid and blinking, and the other cursors
***************
*** 165,182 ****
  are often collapsed into one in that buffer.)
  
  @vindex message-log-max
!   The size of @samp{*Messages*} is limited to a certain number of lines.
! The variable @code{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.  @xref{Variables}, for how to set variables such as
! @code{message-log-max}.
! 
!   The echo area is also used to display the @dfn{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 @kbd{C-g}.  @xref{Minibuffer}.
  
  @node Mode Line
  @section The Mode Line
--- 164,182 ----
  are often collapsed into one in that buffer.)
  
  @vindex message-log-max
!   The size of @samp{*Messages*} is limited to a certain number of
! lines.  The variable @code{message-log-max} specifies how many lines.
! Once the buffer has that many lines, new lines at the end remove lines
! from the beginning to keep the size constant.  @xref{Variables}, for
! how to set variables such as @code{message-log-max}.
! 
!   The echo area is also used to display the @dfn{minibuffer}, a window
! where you can input 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 @kbd{C-g}.
! @xref{Minibuffer}.
  
  @node Mode Line
  @section The Mode Line
***************
*** 191,198 ****
  On a text-mode display, the mode line is in inverse video if the
  terminal supports that; on a graphics display, the mode line has a 3D
  box appearance to help it stand out.  The mode line of the selected
! window has a slightly different appearance than those of other
! windows; see @ref{Optional Mode Line}, for more about this.
  
    Normally, the mode line looks like this:
  
--- 191,198 ----
  On a text-mode display, the mode line is in inverse video if the
  terminal supports that; on a graphics display, the mode line has a 3D
  box appearance to help it stand out.  The mode line of the selected
! window is slightly different from the others; see @ref{Optional Mode
! Line}, for more information.
  
    Normally, the mode line looks like this:
  
***************
*** 201,226 ****
  @end example
  
  @noindent
! 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.
  
    @var{ch} contains two stars @samp{**} if the text in the buffer has
  been edited (the buffer is ``modified''), or @samp{--} if the buffer has
  not been edited.  For a read-only buffer, it is @samp{%*} if the buffer
  is modified, and @samp{%%} otherwise.
  
!   @var{fr} appears only on text-only terminals, to show the selected
! frame name.  @xref{Frames}.  The initial frame's name is @samp{F1}.
  
!   @var{buf} is the name of the window's @dfn{buffer}.  In most cases
! this is the same as the name of a file you are editing.  @xref{Buffers}.
  
!   The buffer displayed in the selected window (the window that the
! cursor is in) is the @dfn{current buffer}--the one that editing takes
! place in.  When we speak of what some command does to ``the buffer,''
! we mean it does those things to the current buffer.
  
    @var{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
--- 201,226 ----
  @end example
  
  @noindent
! This is information about the window and the buffer it displays: 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.
  
    @var{ch} contains two stars @samp{**} if the text in the buffer has
  been edited (the buffer is ``modified''), or @samp{--} if the buffer has
  not been edited.  For a read-only buffer, it is @samp{%*} if the buffer
  is modified, and @samp{%%} otherwise.
  
!   @var{fr} appears only on text-only terminals as the selected frame
! name.  @xref{Frames}.  The initial frame's name is @samp{F1}.
  
!   @var{buf} is the name of the window's @dfn{buffer}.  Usually this is
! the same as the name of a file you are editing.  @xref{Buffers}.
  
!   The buffer displayed in the selected window (the window with the
! cursor) is the @dfn{current buffer}, where editing happens.  When a
! command's effect applies to ``the buffer,'' we mean it does those
! things to the current buffer.
  
    @var{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
***************
*** 232,248 ****
  well.  @xref{Optional Mode Line}.
  
    @var{line} is @samp{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).  @xref{Optional Mode Line}.
  
    @var{major} is the name of the @dfn{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.  @xref{Major Modes}, for details of how the modes differ and how
! to select address@hidden
  
    Some major modes display additional information after the major mode
  name.  For example, Rmail buffers display the current message number and
--- 232,248 ----
  well.  @xref{Optional Mode Line}.
  
    @var{line} is @samp{L} followed by the current line number of point.
! This is present when Line Number mode is enabled (it normally is).
! You can display the current column number too, by turning on Column
! Number mode.  It is not enabled by default because it is somewhat
! slower.  @xref{Optional Mode Line}.
  
    @var{major} is the name of the @dfn{major mode} in effect in the
! buffer.  A buffer can only be in one major mode at a time.  The major
! modes available include Fundamental mode (the least specialized), Text
! mode, Lisp mode, C mode, Texinfo mode, and many others.  @xref{Major
! Modes}, for details of how the modes differ and how to select
! address@hidden
  
    Some major modes display additional information after the major mode
  name.  For example, Rmail buffers display the current message number and
***************
*** 253,266 ****
  turned on at the moment in the window's chosen buffer.  For example,
  @samp{Fill} means that Auto Fill mode is on.  @samp{Abbrev} means that
  Word Abbrev mode is on.  @samp{Ovwrt} means that Overwrite mode is on.
! @xref{Minor Modes}, for more information.  @samp{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.)
  @xref{Narrowing}.  @samp{Def} means that a keyboard macro is being
  defined.  @xref{Keyboard Macros}.
  
!   In addition, if Emacs is currently inside a recursive editing level,
! square brackets (@address@hidden) 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
--- 253,267 ----
  turned on at the moment in the window's chosen buffer.  For example,
  @samp{Fill} means that Auto Fill mode is on.  @samp{Abbrev} means that
  Word Abbrev mode is on.  @samp{Ovwrt} means that Overwrite mode is on.
! @xref{Minor Modes}, for more information.  
! 
!   @samp{Narrow} means that the buffer being displayed has editing
! restricted to only a portion of its text.  This is like a minor mode.
  @xref{Narrowing}.  @samp{Def} means that a keyboard macro is being
  defined.  @xref{Keyboard Macros}.
  
!   In addition, if Emacs is inside a recursive editing level, square
! brackets (@address@hidden) 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
***************
*** 288,330 ****
  all.  @xref{Enabling Multibyte}.
  
  @cindex end-of-line conversion, mode-line indication
!   The colon after @var{cs} can change to another string in certain
! circumstances.  Emacs uses newline characters 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 (@samp{\}) or
! @samp{(DOS)}, depending on the operating system.  If the file uses just
! carriage-return, the colon indicator changes to either a forward slash
! (@samp{/}) or @samp{(Mac)}.  On some systems, Emacs displays
! @samp{(Unix)} instead of the colon even for files that use newline to
! separate lines.
! 
!   @xref{Optional Mode Line}, for features that add other handy
! information to the mode line, such as the size of the buffer, the
! current column number of point, and whether new mail for you has
! arrived.
  
    The mode line is mouse-sensitive; when you move the mouse across
! various parts of it, Emacs displays help text to say what a click in
! that place will do.  @xref{Mode Line Mouse}.
  
  @node Menu Bar
  @section The Menu Bar
  @cindex menu bar
  
    Each Emacs frame normally has a @dfn{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.
  
  @kindex M-`
  @kindex F10
  @findex tmm-menubar
    On a graphical terminal, 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; @samp{...} at the
! end means that the command will read arguments (further input from
! you) before it actually does anything.
  
    To view the full command name and documentation for a menu item, type
  @kbd{C-h k}, and then select the menu bar with the mouse in the usual
--- 289,330 ----
  all.  @xref{Enabling Multibyte}.
  
  @cindex end-of-line conversion, mode-line indication
!   The colon after @var{cs} can change to another string sometimes.
! Emacs uses newline characters 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
! (@samp{\}) or @samp{(DOS)}, depending on the operating system.  If the
! file uses just carriage-return, the colon indicator changes to either
! a forward slash (@samp{/}) or @samp{(Mac)}.  On some systems, Emacs
! displays @samp{(Unix)} instead of the colon even for files that use
! newline to separate lines.
! 
!   @xref{Optional Mode Line}, to add other handy information to the
! mode line, such as the size of the buffer, the current column number
! of point, and whether new mail for you has arrived.
  
    The mode line is mouse-sensitive; when you move the mouse across
! various parts of it, you'll see help text to say what a click in that
! place will do.  @xref{Mode Line Mouse}.
  
  @node Menu Bar
  @section The Menu Bar
  @cindex menu bar
  
    Each Emacs frame normally has a @dfn{menu bar} at the top which you
! can use to perform common operations.  There's no need to list them
! here, as you can more easily see them yourself.
  
  @kindex M-`
  @kindex F10
  @findex tmm-menubar
    On a graphical terminal, you can use the mouse to choose a command
! from the menu bar.  When a menu item has an arrow pointing right, it
! leads to a subsidiary menu; @samp{...} at the end means that the
! command invoked will read arguments (further input from you) before it
! actually does anything.
  
    To view the full command name and documentation for a menu item, type
  @kbd{C-h k}, and then select the menu bar with the mouse in the usual
***************
*** 332,351 ****
  
    On text-only terminals with no mouse, you can use the menu bar by
  typing @kbd{M-`} or @key{F10} (these run the command
! @code{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 up and down arrow keys to move through the
! menu to different choices.  When you have found the choice you want,
! type @key{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 @samp{=>}.  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.
  
  @ignore
     arch-tag: 104ba40e-d972-4866-a542-a98be94bdf2f
--- 332,349 ----
  
    On text-only terminals with no mouse, you can use the menu bar by
  typing @kbd{M-`} or @key{F10} (these run the command
! @code{tmm-menubar}).  This lets you select a menu item from the
! keyboard.  A provisional choice appears in the echo area.  You can use
! the up and down arrow keys to move through the menu to different
! items, and then you can type @key{RET} to select the item..
! 
!   You'll see that each menu item in the text-only menubar also has an
! assigned letter or digit which designates that item; it is usually the
! initial of some word in the item's name.  You can type the item's
! letter or digit to select it.
  
    Some of the commands in the menu bar have ordinary key bindings as
! well; one binding will be in parentheses after the item itself.
  
  @ignore
     arch-tag: 104ba40e-d972-4866-a542-a98be94bdf2f