Groff \# comments.

[gnu-emacs] / src / undo.c

diff --git a/src/undo.c b/src/undo.c
index 5483060eb481cad219ac157c61a72bd6219041a8..7a6ba37d0f88e056b409f410a52f9a976c716db4 100644 (file)
--- a/src/undo.c
+++ b/src/undo.c
@@ -1,6 +1,6 @@
 /* undo handling for GNU Emacs.
-   Copyright (C) 1990, 1993, 1994, 2000, 2002, 2004, 2005
-       Free Software Foundation, Inc.
+   Copyright (C) 1990, 1993, 1994, 2000, 2001, 2002, 2003, 2004,
+                 2005, 2006, 2007  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -16,14 +16,15 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GNU Emacs; see the file COPYING.  If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA.  */
 
 
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"
 #include "commands.h"
+#include "window.h"
 
 /* Limits controlling how much undo information to keep.  */
 
@@ -100,12 +101,19 @@ record_point (pt)
   /* If we are just after an undo boundary, and
      point wasn't at start of deleted range, record where it was.  */
   if (at_boundary
-      && last_point_position != pt
-      /* If we're called from batch mode, this could be nil.  */
       && BUFFERP (last_point_position_buffer)
+      /* If we're called from batch mode, this could be nil.  */
       && current_buffer == XBUFFER (last_point_position_buffer))
-    current_buffer->undo_list
-      = Fcons (make_number (last_point_position), current_buffer->undo_list);
+    {
+      /* If we have switched windows, use the point value
+        from the window we are in.  */
+      if (! EQ (last_point_position_window, selected_window))
+       last_point_position = marker_position (XWINDOW (selected_window)->pointm);
+
+      if (last_point_position != pt)
+       current_buffer->undo_list
+         = Fcons (make_number (last_point_position), current_buffer->undo_list);
+    }
 }
 
 /* Record an insertion that just happened or is about to happen,
@@ -378,11 +386,11 @@ truncate_undo_list (b)
       && size_so_far > XINT (Vundo_outer_limit)
       && !NILP (Vundo_outer_limit_function))
     {
-      Lisp_Object temp = last_undo_buffer;
+      Lisp_Object temp = last_undo_buffer, tem;
 
       /* Normally the function this calls is undo-outer-limit-truncate.  */
-      if (! NILP (call1 (Vundo_outer_limit_function,
-                        make_number (size_so_far))))
+      tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
+      if (! NILP (tem))
        {
          /* The function is responsible for making
             any desired changes in buffer-undo-list.  */
@@ -540,6 +548,8 @@ Return what remains of the list.  */)
                  beg = Fcar (cdr);
                  end = Fcdr (cdr);
 
+                 if (XINT (beg) < BEGV || XINT (end) > ZV)
+                   error ("Changes to be undone are outside visible portion of buffer");
                  Fput_text_property (beg, end, prop, val, Qnil);
                }
              else if (INTEGERP (car) && INTEGERP (cdr))
@@ -556,16 +566,37 @@ Return what remains of the list.  */)
                }
              else if (EQ (car, Qapply))
                {
-                 /* Element (apply FUNNAME . ARGS) means call FUNNAME to undo.  */
+                 /* Element (apply FUN . ARGS) means call FUN to undo.  */
+                 struct buffer *save_buffer = current_buffer;
+
                  car = Fcar (cdr);
+                 cdr = Fcdr (cdr);
                  if (INTEGERP (car))
                    {
-                     /* Long format: (apply DELTA START END FUNNAME . ARGS).  */
-                     cdr = Fcdr (Fcdr (Fcdr (cdr)));
-                     car = Fcar (cdr);
+                     /* Long format: (apply DELTA START END FUN . ARGS).  */
+                     Lisp_Object delta = car;
+                     Lisp_Object start = Fcar (cdr);
+                     Lisp_Object end   = Fcar (Fcdr (cdr));
+                     Lisp_Object start_mark = Fcopy_marker (start, Qnil);
+                     Lisp_Object end_mark   = Fcopy_marker (end, Qt);
+
+                     cdr = Fcdr (Fcdr (cdr));
+                     apply1 (Fcar (cdr), Fcdr (cdr));
+
+                     /* Check that the function did what the entry said it
+                        would do.  */
+                     if (!EQ (start, Fmarker_position (start_mark))
+                         || (XINT (delta) + XINT (end)
+                             != marker_position (end_mark)))
+                       error ("Changes to be undone by function different than announced");
+                     Fset_marker (start_mark, Qnil, Qnil);
+                     Fset_marker (end_mark, Qnil, Qnil);
                    }
-                 cdr = Fcdr (cdr);
-                 apply1 (car, cdr);
+                 else
+                   apply1 (car, cdr);
+
+                 if (save_buffer != current_buffer)
+                   error ("Undo function switched buffer");
                  did_apply = 1;
                }
              else if (STRINGP (car) && INTEGERP (cdr))