xemacs-beta: src/insdel.c comparison

comparison src/insdel.c @ 373:6240c7796c7a r21-2b2

Import from CVS: tag r21-2b2

author	cvs
date	Mon, 13 Aug 2007 11:04:06 +0200
parents	57709be46d1b
children	d883f39b8495

comparison

equal deleted inserted replaced

-:49e1ed2d7ed8
+:6240c7796c7a
 gap_left (struct buffer *buf, Bytind pos)
 {
 Bufbyte *to, *from;
 Bytecount i;
 Bytind new_s1;
+struct buffer *mbuf;
+Lisp_Object bufcons;
 from = BUF_GPT_ADDR (buf);
 to = from + BUF_GAP_SIZE (buf);
 new_s1 = BI_BUF_GPT (buf);
 }
 /* Adjust markers, and buffer data structure, to put the gap at POS.
 POS is where the loop above stopped, which may be what was specified
 or may be where a quit was detected.  */
-adjust_markers (buf, pos, BI_BUF_GPT (buf), BUF_GAP_SIZE (buf));
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-adjust_extents (make_buffer (buf), pos, BI_BUF_GPT (buf),
+{
-		  BUF_GAP_SIZE (buf));
+adjust_markers (mbuf, pos, BI_BUF_GPT (mbuf), BUF_GAP_SIZE (mbuf));
+}
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+adjust_extents (make_buffer (mbuf), pos, BI_BUF_GPT (mbuf),
+		      BUF_GAP_SIZE (mbuf));
+}
 SET_BI_BUF_GPT (buf, pos);
 SET_GAP_SENTINEL (buf);
 #ifdef ERROR_CHECK_EXTENTS
-sledgehammer_extent_check (make_buffer (buf));
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+sledgehammer_extent_check (make_buffer (mbuf));
+}
 #endif
 QUIT;
 }
 static void
 gap_right (struct buffer *buf, Bytind pos)
 {
 Bufbyte *to, *from;
 Bytecount i;
 Bytind new_s1;
+struct buffer *mbuf;
+Lisp_Object bufcons;
 to = BUF_GPT_ADDR (buf);
 from = to + BUF_GAP_SIZE (buf);
 new_s1 = BI_BUF_GPT (buf);
 	}
 }
 {
 int gsize = BUF_GAP_SIZE (buf);
-adjust_markers (buf, BI_BUF_GPT (buf) + gsize, pos + gsize, - gsize);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-adjust_extents (make_buffer (buf), BI_BUF_GPT (buf) + gsize, pos + gsize,
+{
-		    - gsize);
+	adjust_markers (mbuf, BI_BUF_GPT (mbuf) + gsize, pos + gsize, - gsize);
+}
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+	adjust_extents (make_buffer (mbuf), BI_BUF_GPT (mbuf) + gsize,
+			pos + gsize, - gsize);
+}
 SET_BI_BUF_GPT (buf, pos);
 SET_GAP_SENTINEL (buf);
 #ifdef ERROR_CHECK_EXTENTS
-sledgehammer_extent_check (make_buffer (buf));
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+	sledgehammer_extent_check (make_buffer (mbuf));
+}
 #endif
 }
 if (pos == BI_BUF_Z (buf))
 {
 /* merge gap with end gap */
 static int inside_change_hook;
 static Lisp_Object
 change_function_restore (Lisp_Object buffer)
 {
+/* We should first reset the variable and then change the buffer,
+because Fset_buffer() can throw.  */
+inside_change_hook = 0;
 Fset_buffer (buffer);
-inside_change_hook = 0;
 return Qnil;
 }
 static int in_first_change;
 static Lisp_Object
 first_change_hook_restore (Lisp_Object buffer)
 {
+in_first_change = 0;
 Fset_buffer (buffer);
-in_first_change = 0;
 return Qnil;
 }
 /* Signal an initial modification to the buffer.  */
 Lisp_Object buffer;
 XSETBUFFER (buffer, current_buffer);
 if (!in_first_change)
 {
-if (!preparing_for_armageddon &&
+if (!NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
-	  !NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
 	{
 	  int speccount = specpdl_depth ();
 	  record_unwind_protect (first_change_hook_restore, buffer);
 	  set_buffer_internal (buf);
 	  in_first_change = 1;
 static void
 signal_before_change (struct buffer *buf, Bufpos start, Bufpos end)
 {
 /* This function can GC */
-Lisp_Object buffer;
+struct buffer *mbuf;
-XSETBUFFER (buffer, buf);
+Lisp_Object bufcons;
 if (!inside_change_hook)
 {
+Lisp_Object buffer;
 /* Are we in a multiple-change session? */
 if (buf->text->changes->in_multiple_change &&
 	  buf->text->changes->mc_begin != 0)
 	{
 	  /* If we're violating the constraints of the session,
 	    }
 	}
 /* If buffer is unmodified, run a special hook for that case.  */
 if (BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
-	signal_first_change (buf);
+	{
+	  MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	    {
+	      signal_first_change (mbuf);
+	    }
+	}
 /* Now in any case run the before-change-functions if any.  */
-if (!preparing_for_armageddon &&
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-	  (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer)) ||
+	{
-	   /* Obsolete, for compatibility */
+	  XSETBUFFER (buffer, mbuf);
-	   !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer))))
+	  if (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer))
-	{
+	      /* Obsolete, for compatibility */
-	  int speccount = specpdl_depth ();
+	      || !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer)))
-	  record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+	    {
-	  set_buffer_internal (buf);
+	      int speccount = specpdl_depth ();
-	  inside_change_hook = 1;
+	      record_unwind_protect (change_function_restore, Fcurrent_buffer ());
-	  va_run_hook_with_args (Qbefore_change_functions, 2,
+	      set_buffer_internal (buf);
-				 make_int (start), make_int (end));
+	      inside_change_hook = 1;
-	  /* Obsolete, for compatibility */
+	      va_run_hook_with_args (Qbefore_change_functions, 2,
-	  va_run_hook_with_args (Qbefore_change_function, 2,
+				     make_int (start), make_int (end));
-				 make_int (start), make_int (end));
+	      /* Obsolete, for compatibility */
-	  unbind_to (speccount, Qnil);
+	      va_run_hook_with_args (Qbefore_change_function, 2,
+				     make_int (start), make_int (end));
+	      unbind_to (speccount, Qnil);
+	    }
+	}
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  XSETBUFFER (buffer, mbuf);
+	  report_extent_modification (buffer, start, end,
+				      &inside_change_hook, 0);
 	}
 /* Only now do we indicate that the before-change-functions have
 	 been called, in case some function throws out. */
 buf->text->changes->mc_begin_signaled = 1;
 }
-/* #### At this point we should map over extents calling
-modification-hooks, insert-before-hooks and insert-after-hooks
-of relevant extents */
 }
 /* Signal a change immediately after it happens.
 START is the bufpos of the start of the changed text.
 ORIG_END is the bufpos of the end of the before-changed text.
 static void
 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
 		     Bufpos new_end)
 {
 /* This function can GC */
-Lisp_Object buffer;
+struct buffer *mbuf;
-XSETBUFFER (buffer, buf);
+Lisp_Object bufcons;
-/* always do this. */
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-buffer_signal_changed_region (buf, start, new_end);
+{
-font_lock_maybe_update_syntactic_caches (buf, start, orig_end, new_end);
+/* always do this. */
+buffer_signal_changed_region (mbuf, start, new_end);
+}
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+/* #### This seems inefficient.  Wouldn't it be better to just
+keep one cache per base buffer?  */
+font_lock_maybe_update_syntactic_caches (mbuf, start, orig_end, new_end);
+}
 if (!inside_change_hook)
 {
+Lisp_Object buffer;
 if (buf->text->changes->in_multiple_change &&
 	  buf->text->changes->mc_begin != 0)
 	{
 	  assert (start >= buf->text->changes->mc_begin &&
 		  start <= buf->text->changes->mc_new_end);
 		  orig_end <= buf->text->changes->mc_new_end);
 	  buf->text->changes->mc_new_end += new_end - orig_end;
 	  return; /* after-change-functions signalled when all changes done */
 	}
-if (!preparing_for_armageddon &&
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-	  (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer)) ||
+	{
-	   /* Obsolete, for compatibility */
+	  XSETBUFFER (buffer, mbuf);
-	   !NILP (symbol_value_in_buffer (Qafter_change_function, buffer))))
-	{
+	  if (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer))
-	  int speccount = specpdl_depth ();
+	      /* Obsolete, for compatibility */
-	  record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+	      || !NILP (symbol_value_in_buffer (Qafter_change_function, buffer)))
-	  set_buffer_internal (buf);
+	    {
-	  inside_change_hook = 1;
+	      int speccount = specpdl_depth ();
-	  /* The actual after-change functions take slightly
+	      record_unwind_protect (change_function_restore, Fcurrent_buffer ());
-	     different arguments than what we were passed. */
+	      set_buffer_internal (buf);
-	  va_run_hook_with_args (Qafter_change_functions, 3,
+	      inside_change_hook = 1;
-				 make_int (start), make_int (new_end),
+	      /* The actual after-change functions take slightly
-				 make_int (orig_end - start));
+		 different arguments than what we were passed. */
-	  /* Obsolete, for compatibility */
+	      va_run_hook_with_args (Qafter_change_functions, 3,
-	  va_run_hook_with_args (Qafter_change_function, 3,
+				     make_int (start), make_int (new_end),
-				 make_int (start), make_int (new_end),
+				     make_int (orig_end - start));
-				 make_int (orig_end - start));
+	      /* Obsolete, for compatibility */
-	  unbind_to (speccount, Qnil);
+	      va_run_hook_with_args (Qafter_change_function, 3,
-	}
+				     make_int (start), make_int (new_end),
-}
+				     make_int (orig_end - start));
+	      unbind_to (speccount, Qnil);
-/* #### At this point we should map over extents calling
+	    }
-some sort of modification hooks of relevant extents */
+	}
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  XSETBUFFER (buffer, mbuf);
+	  report_extent_modification (buffer, start, new_end,
+				      &inside_change_hook, 1);
+	}
+}
 }
 /* Call this if you're about to change the region of BUFFER from START
 to END.  This checks the read-only properties of the region, calls
 the necessary modification hooks, and warns the next redisplay that
 {
 /* This function can GC */
 /* dmoore - This function can also kill the buffer buf, the current
 buffer, and do anything it pleases.  So if you call it, be
 careful. */
-Lisp_Object buffer;
+struct buffer *mbuf;
+Lisp_Object buffer, bufcons;
 struct gcpro gcpro1;
-barf_if_buffer_read_only (buf, start, end);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+barf_if_buffer_read_only (mbuf, start, end);
+}
 /* if this is the first modification, see about locking the buffer's
 file */
 XSETBUFFER (buffer, buf);
 GCPRO1 (buffer);
 #if 0 /* FSFmacs */
 Vdeactivate_mark = Qt;
 #endif
-buf->point_before_scroll = Qnil;
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+mbuf->point_before_scroll = Qnil;
+}
 }
 /************************************************************************/
 /*                        Insertion of strings                          */
 /* This function can GC */
 struct gcpro gcpro1;
 Bytind ind;
 Charcount cclen;
 int move_point = 0;
+struct buffer *mbuf;
+Lisp_Object bufcons;
 /* Defensive steps just in case a buffer gets deleted and a calling
 function doesn't notice it. */
 if (!BUFFER_LIVE_P (buf))
 return 0;
 /* Make sure that point-max won't exceed the size of an emacs int. */
 if ((length + BUF_Z (buf)) > EMACS_INT_MAX)
 error ("Maximum buffer size exceeded");
-/* theoretically not necessary -- caller should GCPRO */
+/* theoretically not necessary -- caller should GCPRO.
+#### buffer_insert_from_buffer_1() doesn't!  */
 GCPRO1 (reloc);
 prepare_to_modify_buffer (buf, pos, pos, !(flags & INSDEL_NO_LOCKING));
 /* Defensive steps in case the before-change-functions fuck around */
 	make_gap (buf, length - BUF_GAP_SIZE (buf));
 }
 insert_invalidate_line_number_cache (buf, pos, nonreloc + offset, length);
-record_insert (buf, pos, cclen);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+record_insert (mbuf, pos, cclen);
+}
 BUF_MODIFF (buf)++;
 MARK_BUFFERS_CHANGED;
 /* string may have been relocated up to this point */
 if (STRINGP (reloc))
 memcpy (BUF_GPT_ADDR (buf), nonreloc + offset, length);
 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) - length);
 SET_BI_BUF_GPT (buf, BI_BUF_GPT (buf) + length);
-SET_BOTH_BUF_ZV (buf, BUF_ZV (buf) + cclen, BI_BUF_ZV (buf) + length);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) + cclen, BI_BUF_ZV (mbuf) + length);
+}
 SET_BOTH_BUF_Z (buf, BUF_Z (buf) + cclen, BI_BUF_Z (buf) + length);
 SET_GAP_SENTINEL (buf);
 #ifdef MULE
 buffer_mule_signal_inserted_region (buf, pos, length, cclen);
 #endif
-process_extents_for_insertion (make_buffer (buf), ind, length);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-/* We know the gap is at IND so the cast is OK. */
+{
-adjust_markers_for_insert (buf, (Memind) ind, length);
+process_extents_for_insertion (make_buffer (mbuf), ind, length);
+}
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+/* We know the gap is at IND so the cast is OK. */
+adjust_markers_for_insert (mbuf, (Memind) ind, length);
+}
 /* Point logically doesn't move, but may need to be adjusted because
 it's a byte index.  point-marker doesn't change because it's a
 memory index. */
-if (BI_BUF_PT (buf) > ind)
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-JUST_SET_POINT (buf, BUF_PT (buf) + cclen, BI_BUF_PT (buf) + length);
+{
+if (BI_BUF_PT (mbuf) > ind)
+	JUST_SET_POINT (mbuf, BUF_PT (mbuf) + cclen,
+			BI_BUF_PT (mbuf) + length);
+}
 /* Well, point might move. */
 if (move_point)
 BI_BUF_SET_PT (buf, ind + length);
 if (STRINGP (reloc))
-splice_in_string_extents (reloc, buf, ind, length, offset);
+{
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  splice_in_string_extents (reloc, mbuf, ind, length, offset);
+	}
+}
 if (flags & INSDEL_BEFORE_MARKERS)
 {
-/* ind - 1 is correct because the FROM argument is exclusive.
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-	 I formerly used DEC_BYTIND() but that caused problems at the
+	{
-	 beginning of the buffer. */
+	  /* ind - 1 is correct because the FROM argument is exclusive.
-adjust_markers (buf, ind - 1, ind, length);
+	     I formerly used DEC_BYTIND() but that caused problems at the
+	     beginning of the buffer. */
+	  adjust_markers (mbuf, ind - 1, ind, length);
+	}
 }
 signal_after_change (buf, pos, pos, pos + cclen);
 UNGCPRO;
 Charcount
 buffer_insert_lisp_string_1 (struct buffer *buf, Bufpos pos, Lisp_Object str,
 			     int flags)
 {
 /* This function can GC */
+#ifdef ERROR_CHECK_TYPECHECK
 assert (STRINGP (str));
+#endif
 return buffer_insert_string_1 (buf, pos, 0, str, 0,
 				 XSTRING_LENGTH (str),
 				 flags);
 }
 Charcount
 buffer_insert_c_string_1 (struct buffer *buf, Bufpos pos, CONST char *s,
 			  int flags)
 {
 /* This function can GC */
 CONST char *translated = GETTEXT (s);
 return buffer_insert_string_1 (buf, pos, (CONST Bufbyte *) translated, Qnil,
 				 0, strlen (translated), flags);
 }
 buffer_insert_emacs_char_1 (struct buffer *buf, Bufpos pos, Emchar ch,
 			    int flags)
 {
 /* This function can GC */
 Bufbyte str[MAX_EMCHAR_LEN];
-Bytecount len;
+Bytecount len = set_charptr_emchar (str, ch);
-len = set_charptr_emchar (str, ch);
 return buffer_insert_string_1 (buf, pos, str, Qnil, 0, len, flags);
 }
 Charcount
 buffer_insert_c_char_1 (struct buffer *buf, Bufpos pos, char c,
 /* This function can GC */
 Charcount numdel;
 Bytind bi_from, bi_to;
 Bytecount bc_numdel;
 EMACS_INT shortage;
-Lisp_Object bufobj;
+struct buffer *mbuf;
+Lisp_Object bufcons;
 /* Defensive steps just in case a buffer gets deleted and a calling
 function doesn't notice it. */
 if (!BUFFER_LIVE_P (buf))
 return;
 if (to > BUF_ZV (buf))
 to = BUF_ZV (buf);
 if ((numdel = to - from) <= 0)
 return;
-XSETBUFFER (bufobj, buf);
 /* Redisplay needs to know if a newline was in the deleted region.
 If we've already marked the changed region as having a deleted
 newline there is no use in performing the check. */
 if (!buf->changes->newline_was_deleted)
 {
 scan_buffer (buf, '\n', from, to, 1, &shortage, 1);
 if (!shortage)
-	buf->changes->newline_was_deleted = 1;
+	{
+	  MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	    {
+	      mbuf->changes->newline_was_deleted = 1;
+	    }
+	}
 }
 bi_from = bufpos_to_bytind (buf, from);
 bi_to = bufpos_to_bytind (buf, to);
 bc_numdel = bi_to - bi_from;
 if (to == BUF_Z (buf) &&
 bi_from > BI_BUF_GPT (buf))
 {
 /* avoid moving the gap just to delete from the bottom. */
-record_delete (buf, from, numdel);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  record_delete (mbuf, from, numdel);
+	}
 BUF_MODIFF (buf)++;
 MARK_BUFFERS_CHANGED;
-/* ### Point used to be modified here, but this causes problems with MULE,
+/* #### Point used to be modified here, but this causes problems
-	 as point is used to calculate bytinds, and if the offset in bc_numdel causes
+	 with MULE, as point is used to calculate bytinds, and if the
-	 point to move to a non first-byte location, causing some other function to
+	 offset in bc_numdel causes point to move to a non first-byte
-	 throw an assertion in ASSERT_VALID_BYTIND. I've moved the code to right after
+	 location, causing some other function to throw an assertion
-	  the other movements and adjustments, but before the gap is moved.
+	 in ASSERT_VALID_BYTIND. I've moved the code to right after
-	  -- jh 970813 */
+	 the other movements and adjustments, but before the gap is
+	 moved.  -- jh 970813 */
 /* Detach any extents that are completely within the range [FROM, TO],
 	 if the extents are detachable.
-	 This must come AFTER record_delete(), so that the appropriate extents
+	 This must come AFTER record_delete(), so that the appropriate
-	 will be present to be recorded, and BEFORE the gap size is increased,
+	 extents will be present to be recorded, and BEFORE the gap
-	 as otherwise we will be confused about where the extents end. */
+	 size is increased, as otherwise we will be confused about
-process_extents_for_deletion (bufobj, bi_from, bi_to, 0);
+	 where the extents end. */
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-/* Relocate all markers pointing into the new, larger gap
+	{
-	 to point at the end of the text before the gap.  */
+	  process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
-adjust_markers (buf,
+	}
-		      (bi_to + BUF_GAP_SIZE (buf)),
-		      (bi_to + BUF_GAP_SIZE (buf)),
+/* Relocate all markers pointing into the new, larger gap to
-		      (- bc_numdel));
+	 point at the end of the text before the gap.  */
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-/* Relocate any extent endpoints just like markers. */
+	{
-adjust_extents_for_deletion (bufobj, bi_from, bi_to,
+	  adjust_markers (mbuf,
-				   BUF_GAP_SIZE (buf), bc_numdel, 0);
+			  (bi_to + BUF_GAP_SIZE (mbuf)),
+			  (bi_to + BUF_GAP_SIZE (mbuf)),
-/* Relocate point as if it were a marker.  */
+			  (- bc_numdel));
-if (bi_from < BI_BUF_PT (buf))
+	}
-	{
-	  if (BI_BUF_PT (buf) < bi_to)
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-	    JUST_SET_POINT (buf, from, bi_from);
+	{
-	  else
+	  /* Relocate any extent endpoints just like markers. */
-	    JUST_SET_POINT (buf, BUF_PT (buf) - numdel,
+	  adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
-			    BI_BUF_PT (buf) - bc_numdel);
+				       BUF_GAP_SIZE (mbuf), bc_numdel, 0);
+	}
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  /* Relocate point as if it were a marker.  */
+	  if (bi_from < BI_BUF_PT (mbuf))
+	    {
+	      if (BI_BUF_PT (mbuf) < bi_to)
+		JUST_SET_POINT (mbuf, from, bi_from);
+	      else
+		JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
+				BI_BUF_PT (mbuf) - bc_numdel);
+	    }
 	}
 SET_BUF_END_GAP_SIZE (buf, BUF_END_GAP_SIZE (buf) + bc_numdel);
-SET_BOTH_BUF_ZV (buf, BUF_ZV (buf) - numdel, BI_BUF_ZV (buf) - bc_numdel);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
+			   BI_BUF_ZV (mbuf) - bc_numdel);
+	}
 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
 SET_GAP_SENTINEL (buf);
 }
 else
 {
 if (bi_to < BI_BUF_GPT (buf))
 	gap_left (buf, bi_to);
 if (bi_from > BI_BUF_GPT (buf))
 	gap_right (buf, bi_from);
-record_delete (buf, from, numdel);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  record_delete (mbuf, from, numdel);
+	}
 BUF_MODIFF (buf)++;
 MARK_BUFFERS_CHANGED;
-/* ### Point used to be modified here, but this causes problems with MULE,
+/* #### Point used to be modified here, but this causes problems
-	 as point is used to calculate bytinds, and if the offset in bc_numdel causes
+	 with MULE, as point is used to calculate bytinds, and if the
-	 point to move to a non first-byte location, causing some other function to
+	 offset in bc_numdel causes point to move to a non first-byte
-	 throw an assertion in ASSERT_VALID_BYTIND. I've moved the code to right after
+	 location, causing some other function to throw an assertion
-	  the other movements and adjustments, but before the gap is moved.
+	 in ASSERT_VALID_BYTIND. I've moved the code to right after
-	  -- jh 970813 */
+	 the other movements and adjustments, but before the gap is
+	 moved.  -- jh 970813 */
 /* Detach any extents that are completely within the range [FROM, TO],
 	 if the extents are detachable.
 	 This must come AFTER record_delete(), so that the appropriate extents
 	 will be present to be recorded, and BEFORE the gap size is increased,
 	 as otherwise we will be confused about where the extents end. */
-process_extents_for_deletion (bufobj, bi_from, bi_to, 0);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
-/* Relocate all markers pointing into the new, larger gap
+	  process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
-	 to point at the end of the text before the gap.  */
+	}
-adjust_markers (buf,
-		      (bi_to + BUF_GAP_SIZE (buf)),
+/* Relocate all markers pointing into the new, larger gap to
-		      (bi_to + BUF_GAP_SIZE (buf)),
+	 point at the end of the text before the gap.  */
-		      (- bc_numdel - BUF_GAP_SIZE (buf)));
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  adjust_markers (mbuf,
+			  (bi_to + BUF_GAP_SIZE (mbuf)),
+			  (bi_to + BUF_GAP_SIZE (mbuf)),
+			  (- bc_numdel - BUF_GAP_SIZE (mbuf)));
+	}
 /* Relocate any extent endpoints just like markers. */
-adjust_extents_for_deletion (bufobj, bi_from, bi_to, BUF_GAP_SIZE (buf),
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-				   bc_numdel, BUF_GAP_SIZE (buf));
+	{
+	  adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
-/* Relocate point as if it were a marker.  */
+				       BUF_GAP_SIZE (mbuf),
-if (bi_from < BI_BUF_PT (buf))
+				       bc_numdel, BUF_GAP_SIZE (mbuf));
-	{
+	}
-	  if (BI_BUF_PT (buf) < bi_to)
-	    JUST_SET_POINT (buf, from, bi_from);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-	  else
+	{
-	    JUST_SET_POINT (buf, BUF_PT (buf) - numdel,
+	  /* Relocate point as if it were a marker.  */
-			    BI_BUF_PT (buf) - bc_numdel);
+	  if (bi_from < BI_BUF_PT (mbuf))
+	    {
+	      if (BI_BUF_PT (mbuf) < bi_to)
+		JUST_SET_POINT (mbuf, from, bi_from);
+	      else
+		JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
+				BI_BUF_PT (mbuf) - bc_numdel);
+	    }
 	}
 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + bc_numdel);
-SET_BOTH_BUF_ZV (buf, BUF_ZV (buf) - numdel, BI_BUF_ZV (buf) - bc_numdel);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	{
+	  SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
+			   BI_BUF_ZV (mbuf) - bc_numdel);
+	}
 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
 SET_BI_BUF_GPT (buf, bi_from);
 SET_GAP_SENTINEL (buf);
 }
 #ifdef MULE
 buffer_mule_signal_deleted_region (buf, from, to, bi_from, bi_to);
 #endif
 #ifdef ERROR_CHECK_EXTENTS
-sledgehammer_extent_check (bufobj);
+MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+{
+sledgehammer_extent_check (make_buffer (mbuf));
+}
 #endif
 signal_after_change (buf, from, to, from);
 }
 /************************************************************************/
 /* Replace the character at POS in buffer B with CH. */
 void
-buffer_replace_char (struct buffer *b, Bufpos pos, Emchar ch,
+buffer_replace_char (struct buffer *buf, Bufpos pos, Emchar ch,
 		     int not_real_change, int force_lock_check)
 {
 /* This function can GC */
 Bufbyte curstr[MAX_EMCHAR_LEN];
 Bufbyte newstr[MAX_EMCHAR_LEN];
 Bytecount curlen, newlen;
 /* Defensive steps just in case a buffer gets deleted and a calling
 function doesn't notice it. */
-if (!BUFFER_LIVE_P (b))
+if (!BUFFER_LIVE_P (buf))
 return;
-curlen = BUF_CHARPTR_COPY_CHAR (b, pos, curstr);
+curlen = BUF_CHARPTR_COPY_CHAR (buf, pos, curstr);
 newlen = set_charptr_emchar (newstr, ch);
 if (curlen == newlen)
 {
+struct buffer *mbuf;
+Lisp_Object bufcons;
 /* then we can just replace the text. */
-prepare_to_modify_buffer (b, pos, pos + 1,
+prepare_to_modify_buffer (buf, pos, pos + 1,
 				!not_real_change || force_lock_check);
 /* Defensive steps in case the before-change-functions fuck around */
-if (!BUFFER_LIVE_P (b))
+if (!BUFFER_LIVE_P (buf))
 	/* Bad bad pre-change function. */
 	return;
 /* Make args be valid again.  prepare_to_modify_buffer() might have
 	 modified the buffer. */
-if (pos < BUF_BEGV (b))
+if (pos < BUF_BEGV (buf))
-	pos = BUF_BEGV (b);
+	pos = BUF_BEGV (buf);
-if (pos >= BUF_ZV (b))
+if (pos >= BUF_ZV (buf))
-	pos = BUF_ZV (b) - 1;
+	pos = BUF_ZV (buf) - 1;
-if (pos < BUF_BEGV (b))
+if (pos < BUF_BEGV (buf))
 	/* no more characters in buffer! */
 	return;
-if (BUF_FETCH_CHAR (b, pos) == '\n')
+if (BUF_FETCH_CHAR (buf, pos) == '\n')
-	b->changes->newline_was_deleted = 1;
+	{
+	  MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+	    {
+	      mbuf->changes->newline_was_deleted = 1;
+	    }
+	}
 MARK_BUFFERS_CHANGED;
 if (!not_real_change)
 	{
-	  record_change (b, pos, 1);
+	  MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
-	  BUF_MODIFF (b)++;
+	    {
-	}
+	      record_change (mbuf, pos, 1);
-memcpy (BUF_BYTE_ADDRESS (b, pos), newstr, newlen);
+	    }
-signal_after_change (b, pos, pos + 1, pos + 1);
+	  BUF_MODIFF (buf)++;
+	}
+memcpy (BUF_BYTE_ADDRESS (buf, pos), newstr, newlen);
+signal_after_change (buf, pos, pos + 1, pos + 1);
 /* We do not have to adjust the Mule data; we just replaced a
 	 character with another of the same number of bytes. */
 }
 else
 * Make a note to move point forward later in the one situation
 * where it is needed, a delete/insert one position behind
 * point.  Point will drift backward by one position and stay
 * there otherwise.
 */
-int movepoint = (pos == BUF_PT (b) - 1);
+int movepoint = (pos == BUF_PT (buf) - 1);
-buffer_delete_range (b, pos, pos + 1, 0);
+buffer_delete_range (buf, pos, pos + 1, 0);
 /* Defensive steps in case the before-change-functions fuck around */
-if (!BUFFER_LIVE_P (b))
+if (!BUFFER_LIVE_P (buf))
 	/* Bad bad pre-change function. */
 	return;
 /* Make args be valid again.  prepare_to_modify_buffer() might have
 	 modified the buffer. */
-if (pos < BUF_BEGV (b))
+if (pos < BUF_BEGV (buf))
-	pos = BUF_BEGV (b);
+	pos = BUF_BEGV (buf);
-if (pos >= BUF_ZV (b))
+if (pos >= BUF_ZV (buf))
-	pos = BUF_ZV (b) - 1;
+	pos = BUF_ZV (buf) - 1;
-if (pos < BUF_BEGV (b))
+if (pos < BUF_BEGV (buf))
 	/* no more characters in buffer! */
 	return;
 /*
 * -1 as the pos argument means to move point forward with the
 * insertion, which we must do if the deletion moved point
 * backward so that it now equals the insertion point.
 */
-buffer_insert_string_1 (b, (movepoint ? -1 : pos),
+buffer_insert_string_1 (buf, (movepoint ? -1 : pos),
 			      newstr, Qnil, 0, newlen, 0);
 }
 }
 for (i = 0; i <= MAX_BYTIND_GAP_SIZE_3; i++)
 three_to_one_table[i] = i / 3;
 }
 void
-init_buffer_text (struct buffer *b, int indirect_p)
+init_buffer_text (struct buffer *b)
 {
-if (!indirect_p)
+if (!b->base_buffer)
 {
 SET_BUF_GAP_SIZE (b, 20);
 BUFFER_ALLOC (b->text->beg, BUF_GAP_SIZE (b) + BUF_END_SENTINEL_SIZE);
 if (! BUF_BEG_ADDR (b))
 	memory_full ();
 	    b->text->mule_bufpos_cache[i] = 1;
 	    b->text->mule_bytind_cache[i] = 1;
 	  }
 }
 #endif /* MULE */
+b->text->line_number_cache = Qnil;
 BUF_MODIFF (b) = 1;
 BUF_SAVE_MODIFF (b) = 1;
 JUST_SET_POINT (b, 1, 1);
 b->width_table = Qnil;
 #endif
 }
 void
-uninit_buffer_text (struct buffer *b, int indirect_p)
+uninit_buffer_text (struct buffer *b)
 {
-if (!indirect_p)
+if (!b->base_buffer)
 {
 BUFFER_FREE (b->text->beg);
 xfree (b->text->changes);
 }
 xfree (b->changes);

Mercurial > hg > xemacs-beta

comparison src/insdel.c @ 373:6240c7796c7a r21-2b2