X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/e928d437c2a065cb23a37dec3a6a22640d7abfb1..ffdf4f267a4e630e055c1470cae04525dee0784c:/src/undo.c

diff --git a/src/undo.c b/src/undo.c
index af57c4352b..f378ce8aae 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -1,5 +1,5 @@
 /* undo handling for GNU Emacs.
-   Copyright (C) 1990, 1993, 1994 Free Software Foundation, Inc.
+   Copyright (C) 1990, 1993, 1994, 2000 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -36,6 +36,62 @@ Lisp_Object Qinhibit_read_only;
    an undo-boundary.  */
 Lisp_Object pending_boundary;
 
+/* Record point as it was at beginning of this command (if necessary)
+   And prepare the undo info for recording a change.
+   PT is the position of point that will naturally occur as a result of the
+   undo record that will be added just after this command terminates.  */
+
+static void
+record_point (pt)
+     int pt;
+{
+  int at_boundary;
+
+  /* Allocate a cons cell to be the undo boundary after this command.  */
+  if (NILP (pending_boundary))
+    pending_boundary = Fcons (Qnil, Qnil);
+
+  if (!BUFFERP (last_undo_buffer)
+      || current_buffer != XBUFFER (last_undo_buffer))
+    Fundo_boundary ();
+  XSETBUFFER (last_undo_buffer, current_buffer);
+
+  if (CONSP (current_buffer->undo_list))
+    {
+      /* Set AT_BOUNDARY to 1 only when we have nothing other than
+         marker adjustment before undo boundary.  */
+
+      Lisp_Object tail = current_buffer->undo_list, elt;
+
+      while (1)
+	{
+	  if (NILP (tail))
+	    elt = Qnil;
+	  else
+	    elt = XCAR (tail);
+	  if (NILP (elt) || ! (CONSP (elt) && MARKERP (XCAR (elt))))
+	    break;
+	  tail = XCDR (tail);
+	}
+      at_boundary = NILP (elt);
+    }
+  else
+    at_boundary = 1;
+
+  if (MODIFF <= SAVE_MODIFF)
+    record_first_change ();
+
+  /* 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)
+      && current_buffer == XBUFFER (last_point_position_buffer))
+    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,
    for LENGTH characters at position BEG.
    (It is possible to record an insertion before or after the fact
@@ -50,29 +106,20 @@ record_insert (beg, length)
   if (EQ (current_buffer->undo_list, Qt))
     return;
 
-  /* Allocate a cons cell to be the undo boundary after this command.  */
-  if (NILP (pending_boundary))
-    pending_boundary = Fcons (Qnil, Qnil);
-
-  if (current_buffer != XBUFFER (last_undo_buffer))
-    Fundo_boundary ();
-  XSETBUFFER (last_undo_buffer, current_buffer);
-
-  if (MODIFF <= SAVE_MODIFF)
-    record_first_change ();
+  record_point (beg);
 
   /* If this is following another insertion and consecutive with it
      in the buffer, combine the two.  */
   if (CONSP (current_buffer->undo_list))
     {
       Lisp_Object elt;
-      elt = XCONS (current_buffer->undo_list)->car;
+      elt = XCAR (current_buffer->undo_list);
       if (CONSP (elt)
-	  && INTEGERP (XCONS (elt)->car)
-	  && INTEGERP (XCONS (elt)->cdr)
-	  && XINT (XCONS (elt)->cdr) == beg)
+	  && INTEGERP (XCAR (elt))
+	  && INTEGERP (XCDR (elt))
+	  && XINT (XCDR (elt)) == beg)
 	{
-	  XSETINT (XCONS (elt)->cdr, beg + length);
+	  XSETCDR (elt, make_number (beg + length));
 	  return;
 	}
     }
@@ -92,37 +139,20 @@ record_delete (beg, string)
      Lisp_Object string;
 {
   Lisp_Object sbeg;
-  int at_boundary;
 
   if (EQ (current_buffer->undo_list, Qt))
     return;
 
-  /* Allocate a cons cell to be the undo boundary after this command.  */
-  if (NILP (pending_boundary))
-    pending_boundary = Fcons (Qnil, Qnil);
-
-  if (current_buffer != XBUFFER (last_undo_buffer))
-    Fundo_boundary ();
-  XSETBUFFER (last_undo_buffer, current_buffer);
-
-  at_boundary = (CONSP (current_buffer->undo_list)
-		 && NILP (XCONS (current_buffer->undo_list)->car));
-
-  if (MODIFF <= SAVE_MODIFF)
-    record_first_change ();
-
-  if (PT == beg + XSTRING (string)->size)
-    XSETINT (sbeg, -beg);
+  if (PT == beg + SCHARS (string))
+    {
+      XSETINT (sbeg, -beg);
+      record_point (PT);
+    }
   else
-    XSETFASTINT (sbeg, beg);
-
-  /* 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 != XFASTINT (sbeg)
-      && current_buffer == XBUFFER (last_point_position_buffer))
-    current_buffer->undo_list
-      = Fcons (make_number (last_point_position), current_buffer->undo_list);
+    {
+      XSETFASTINT (sbeg, beg);
+      record_point (beg);
+    }
 
   current_buffer->undo_list
     = Fcons (Fcons (string, sbeg), current_buffer->undo_list);
@@ -145,7 +175,8 @@ record_marker_adjustment (marker, adjustment)
   if (NILP (pending_boundary))
     pending_boundary = Fcons (Qnil, Qnil);
 
-  if (current_buffer != XBUFFER (last_undo_buffer))
+  if (!BUFFERP (last_undo_buffer) 
+      || current_buffer != XBUFFER (last_undo_buffer))
     Fundo_boundary ();
   XSETBUFFER (last_undo_buffer, current_buffer);
 
@@ -179,7 +210,8 @@ record_first_change ()
   if (EQ (current_buffer->undo_list, Qt))
     return;
 
-  if (current_buffer != XBUFFER (last_undo_buffer))
+  if (!BUFFERP (last_undo_buffer)
+      || current_buffer != XBUFFER (last_undo_buffer))
     Fundo_boundary ();
   XSETBUFFER (last_undo_buffer, current_buffer);
 
@@ -232,10 +264,10 @@ record_property_change (beg, length, prop, value, buffer)
 }
 
 DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
-  "Mark a boundary between units of undo.\n\
-An undo command will stop at this point,\n\
-but another undo command will undo to the previous boundary.")
-  ()
+       doc: /* Mark a boundary between units of undo.
+An undo command will stop at this point,
+but another undo command will undo to the previous boundary.  */)
+     ()
 {
   Lisp_Object tem;
   if (EQ (current_buffer->undo_list, Qt))
@@ -248,7 +280,7 @@ but another undo command will undo to the previous boundary.")
 	{
 	  /* If we have preallocated the cons cell to use here,
 	     use that one.  */
-	  XCONS (pending_boundary)->cdr = current_buffer->undo_list;
+	  XSETCDR (pending_boundary, current_buffer->undo_list);
 	  current_buffer->undo_list = pending_boundary;
 	  pending_boundary = Qnil;
 	}
@@ -282,33 +314,33 @@ truncate_undo_list (list, minsize, maxsize)
      Skip, skip, skip the undo, skip, skip, skip the undo,
      Skip, skip, skip the undo, skip to the undo bound'ry. 
      (Get it?  "Skip to my Loo?")  */
-  if (CONSP (next) && NILP (XCONS (next)->car))
+  if (CONSP (next) && NILP (XCAR (next)))
     {
       /* Add in the space occupied by this element and its chain link.  */
       size_so_far += sizeof (struct Lisp_Cons);
 
       /* Advance to next element.  */
       prev = next;
-      next = XCONS (next)->cdr;
+      next = XCDR (next);
     }
-  while (CONSP (next) && ! NILP (XCONS (next)->car))
+  while (CONSP (next) && ! NILP (XCAR (next)))
     {
       Lisp_Object elt;
-      elt = XCONS (next)->car;
+      elt = XCAR (next);
 
       /* Add in the space occupied by this element and its chain link.  */
       size_so_far += sizeof (struct Lisp_Cons);
       if (CONSP (elt))
 	{
 	  size_so_far += sizeof (struct Lisp_Cons);
-	  if (STRINGP (XCONS (elt)->car))
+	  if (STRINGP (XCAR (elt)))
 	    size_so_far += (sizeof (struct Lisp_String) - 1
-			    + XSTRING (XCONS (elt)->car)->size);
+			    + SCHARS (XCAR (elt)));
 	}
 
       /* Advance to next element.  */
       prev = next;
-      next = XCONS (next)->cdr;
+      next = XCDR (next);
     }
   if (CONSP (next))
     last_boundary = prev;
@@ -316,7 +348,7 @@ truncate_undo_list (list, minsize, maxsize)
   while (CONSP (next))
     {
       Lisp_Object elt;
-      elt = XCONS (next)->car;
+      elt = XCAR (next);
 
       /* When we get to a boundary, decide whether to truncate
 	 either before or after it.  The lower threshold, MINSIZE,
@@ -336,14 +368,14 @@ truncate_undo_list (list, minsize, maxsize)
       if (CONSP (elt))
 	{
 	  size_so_far += sizeof (struct Lisp_Cons);
-	  if (STRINGP (XCONS (elt)->car))
+	  if (STRINGP (XCAR (elt)))
 	    size_so_far += (sizeof (struct Lisp_String) - 1
-			    + XSTRING (XCONS (elt)->car)->size);
+			    + SCHARS (XCAR (elt)));
 	}
 
       /* Advance to next element.  */
       prev = next;
-      next = XCONS (next)->cdr;
+      next = XCDR (next);
     }
 
   /* If we scanned the whole list, it is short enough; don't change it.  */
@@ -353,7 +385,7 @@ truncate_undo_list (list, minsize, maxsize)
   /* Truncate at the boundary where we decided to truncate.  */
   if (!NILP (last_boundary))
     {
-      XCONS (last_boundary)->cdr = Qnil;
+      XSETCDR (last_boundary, Qnil);
       return list;
     }
   else
@@ -361,15 +393,16 @@ truncate_undo_list (list, minsize, maxsize)
 }
 
 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
-  "Undo N records from the front of the list LIST.\n\
-Return what remains of the list.")
-  (n, list)
+       doc: /* Undo N records from the front of the list LIST.
+Return what remains of the list.  */)
+     (n, list)
      Lisp_Object n, list;
 {
   struct gcpro gcpro1, gcpro2;
   Lisp_Object next;
-  int count = specpdl_ptr - specpdl;
+  int count = SPECPDL_INDEX ();
   register int arg;
+  
 #if 0  /* This is a good feature, but would make undo-start
 	  unable to do what is expected.  */
   Lisp_Object tem;
@@ -381,21 +414,25 @@ Return what remains of the list.")
     list = Fcdr (list);
 #endif
 
-  CHECK_NUMBER (n, 0);
+  CHECK_NUMBER (n);
   arg = XINT (n);
   next = Qnil;
   GCPRO2 (next, list);
 
-  /* Don't let read-only properties interfere with undo.  */
+  /* In a writable buffer, enable undoing read-only text that is so
+     because of text properties.  */
   if (NILP (current_buffer->read_only))
     specbind (Qinhibit_read_only, Qt);
 
+  /* Don't let `intangible' properties interfere with undo.  */
+  specbind (Qinhibit_point_motion_hooks, Qt);
+
   while (arg > 0)
     {
-      while (1)
+      while (CONSP (list))
 	{
-	  next = Fcar (list);
-	  list = Fcdr (list);
+	  next = XCAR (list);
+	  list = XCDR (list);
 	  /* Exit inner loop at undo boundary.  */
 	  if (NILP (next))
 	    break;
@@ -406,8 +443,8 @@ Return what remains of the list.")
 	    {
 	      Lisp_Object car, cdr;
 
-	      car = Fcar (next);
-	      cdr = Fcdr (next);
+	      car = XCAR (next);
+	      cdr = XCDR (next);
 	      if (EQ (car, Qt))
 		{
 		  /* Element (t high . low) records previous modtime.  */
@@ -432,7 +469,6 @@ Return what remains of the list.")
 #endif /* CLASH_DETECTION */
 		  Fset_buffer_modified_p (Qnil);
 		}
-#ifdef USE_TEXT_PROPERTIES
 	      else if (EQ (car, Qnil))
 		{
 		  /* Element (nil prop val beg . end) is property change.  */
@@ -447,11 +483,9 @@ Return what remains of the list.")
 
 		  Fput_text_property (beg, end, prop, val, Qnil);
 		}
-#endif /* USE_TEXT_PROPERTIES */
 	      else if (INTEGERP (car) && INTEGERP (cdr))
 		{
 		  /* Element (BEG . END) means range was inserted.  */
-		  Lisp_Object end;
 
 		  if (XINT (car) < BEGV
 		      || XINT (cdr) > ZV)
@@ -508,6 +542,7 @@ Return what remains of the list.")
   return unbind_to (count, list);
 }
 
+void
 syms_of_undo ()
 {
   Qinhibit_read_only = intern ("inhibit-read-only");