[Emacs-diffs] /srv/bzr/emacs/emacs-23 r99895: Clarify command loop's role in undo boundary (Bug#2433).

[Chong Yidong]

------------------------------------------------------------
revno: 99895
committer: Chong Yidong <address@hidden>
branch nick: emacs-23
timestamp: Thu 2010-06-24 15:05:47 -0400
message:
  Clarify command loop's role in undo boundary (Bug#2433).
  
  * text.texi (Undo): Clarify command loop behavior (Bug#2433).
  * commands.texi (Command Overview): Mention undo-boundary call.
modified:
  doc/lispref/ChangeLog
  doc/lispref/commands.texi
  doc/lispref/text.texi

=== modified file 'doc/lispref/ChangeLog'
--- a/doc/lispref/ChangeLog     2010-06-23 03:36:56 +0000
+++ b/doc/lispref/ChangeLog     2010-06-24 19:05:47 +0000
@@ -1,3 +1,9 @@
+2010-06-24  Chong Yidong  <address@hidden>
+
+       * text.texi (Undo): Clarify command loop behavior (Bug#2433).
+
+       * commands.texi (Command Overview): Mention undo-boundary call.
+
 2010-06-23  Glenn Morris  <address@hidden>
 
        * abbrevs.texi, commands.texi, compile.texi, debugging.texi:

=== modified file 'doc/lispref/commands.texi'
--- a/doc/lispref/commands.texi 2010-06-23 03:36:56 +0000
+++ b/doc/lispref/commands.texi 2010-06-24 19:05:47 +0000
@@ -53,16 +53,19 @@
 command, which it then calls.  This is done by the command
 @code{execute-extended-command} (@pxref{Interactive Call}).
 
-  To execute a command requires first reading the arguments for it.
-This is done by calling @code{command-execute} (@pxref{Interactive
-Call}).  For commands written in Lisp, the @code{interactive}
-specification says how to read the arguments.  This may use the prefix
-argument (@pxref{Prefix Command Arguments}) or may read with prompting
-in the minibuffer (@pxref{Minibuffers}).  For example, the command
address@hidden has an @code{interactive} specification which says to
-read a file name using the minibuffer.  The command's function body does
-not use the minibuffer; if you call this command from Lisp code as a
-function, you must supply the file name string as an ordinary Lisp
+  Prior to executing the command, Emacs runs @code{undo-boundary} to
+create an undo boundary.  @xref{Maintaining Undo}.
+
+  To execute a command, Emacs first reads its arguments by calling
address@hidden (@pxref{Interactive Call}).  For commands
+written in Lisp, the @code{interactive} specification says how to read
+the arguments.  This may use the prefix argument (@pxref{Prefix
+Command Arguments}) or may read with prompting in the minibuffer
+(@pxref{Minibuffers}).  For example, the command @code{find-file} has
+an @code{interactive} specification which says to read a file name
+using the minibuffer.  The function body of @code{find-file} does not
+use the minibuffer, so if you call @code{find-file} as a function from
+Lisp code, you must supply the file name string as an ordinary Lisp
 function argument.
 
   If the command is a string or vector (i.e., a keyboard macro) then

=== modified file 'doc/lispref/text.texi'
--- a/doc/lispref/text.texi     2010-06-23 03:36:56 +0000
+++ b/doc/lispref/text.texi     2010-06-24 19:05:47 +0000
@@ -1299,13 +1299,16 @@
 command stops at such a boundary, and successive undo commands undo
 to earlier and earlier boundaries.  This function returns @code{nil}.
 
-The editor command loop automatically creates an undo boundary before
-each key sequence is executed.  Thus, each undo normally undoes the
-effects of one command.  Self-inserting input characters are an
-exception.  The command loop makes a boundary for the first such
-character; the next 19 consecutive self-inserting input characters do
-not make boundaries, and then the 20th does, and so on as long as
-self-inserting characters continue.
+The editor command loop automatically calls @code{undo-boundary} just
+before executing each key sequence, so that each undo normally undoes
+the effects of one command.  As an exception, the command
address@hidden, which produces self-inserting input
+characters (@pxref{Commands for Insertion}), may remove the boundary
+inserted by the command loop: a boundary is accepted for the first
+such character, the next 19 consecutive self-inserting input
+characters do not have boundaries, and then the 20th does; and so on
+as long as the self-inserting characters continue.  Hence, sequences
+of consecutive character insertions can be undone as a group.
 
 All buffer modifications add a boundary whenever the previous undoable
 change was made in some other buffer.  This is to ensure that