xemacs-beta: src/insdel.c comparison

comparison src/insdel.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	e121b013d1f0
children	850242ba4a81

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 /*
 There are three possible ways to specify positions in a buffer.  All
 of these are one-based: the beginning of the buffer is position or
 index 1, and 0 is not a valid position.
 As a "buffer position" (typedef Bufpos):
 This is an index specifying an offset in characters from the
 beginning of the buffer.  Note that buffer positions are
 logically *between* characters, not on a character.  The
 Bytecount:
 ----------
 Similar to a Charcount but represents a count of bytes.
 	The difference between two Bytind's is a Bytecount.
 Usage of the various representations:
 =====================================
 Memory indices are used in low-level functions in insdel.c and for
 extent endpoints and marker positions.  The reason for this is that
 except for code that needs to be fast, which used Bytecounts.
 Strings are always passed around internally using internal format.
 Conversions between external format are performed at the time
 that the data goes in or out of Emacs.
 Working with the various representations:
 ========================================= */
 #include <config.h>
 #include "lisp.h"
 #define SET_BUF_GAP_SIZE(buf, value) \
 do { (buf)->text->gap_size = (value); } while (0)
 #define SET_BUF_END_GAP_SIZE(buf, value) \
 do { (buf)->text->end_gap_size = (value); } while (0)
 /* Gap location.  */
 #define BI_BUF_GPT(buf) ((buf)->text->gpt + 0)
 #define BUF_GPT_ADDR(buf) (BUF_BEG_ADDR (buf) + BI_BUF_GPT (buf) - 1)
 /* Set gap location.  */
 #define SET_BI_BUF_GPT(buf, value) do { (buf)->text->gpt = (value); } while (0)
 /* Set end of buffer.  */
 #define SET_BOTH_BUF_Z(buf, val, bival)		\
 do						\
 {						\
 (buf)->text->z = (bival);			\
 (buf)->text->bufz = (val);			\
 call SET_GAP_SENTINEL().
 Every time we change the total size (characters plus gap)
 of the buffer, we have to call SET_END_SENTINEL().
 */
 #ifdef MULE
 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len) + 1)
 # define SET_GAP_SENTINEL(buf) (*BUF_GPT_ADDR (buf) = 0)
 # define BUF_END_SENTINEL_SIZE 1
 	  count++, ptr++;
 	}
 /* Now do it. */
 while (ptr < aligned_end)
 	{
 	  if ((* (unsigned long *) ptr) & HIGH_BIT_MASK)
 	    goto bail;
 	  ptr += LONG_BYTES;
 	  count += LONG_BYTES;
 	}
 function in all of XEmacs.  Therefore, it must be FAST FAST FAST.
 This is the reason why so much of the code is duplicated.
 Similar considerations apply to bytind_to_bufpos_func(), although
 less so because the function is not called so often.
 #### At some point this should use a more sophisticated method;
 see buffer.h. */
 static int not_very_random_number;
 /* #### This value could stand some more exploration. */
 Charcount heuristic_hack = (bufmax - bufmin) >> 2;
 /* Check if the position is closer to PT or ZV than to the
 	 end of the known region. */
 if (diffpt < 0)
 	diffpt = -diffpt;
 if (diffzv < 0)
 	diffzv = -diffzv;
 	 over PT or ZV.  The reason for this is that switching to
 	 PT or ZV will wipe out the knowledge in the known region,
 	 which might be annoying if the known region is large and
 	 PT or ZV is not that much closer than the end of the known
 	 region. */
 diffzv += heuristic_hack;
 diffpt += heuristic_hack;
 if (diffpt < diffmax && diffpt <= diffzv)
 	{
 	  bufmax = bufmin = BUF_PT (buf);
 if (diffbegv < 0)
 	diffbegv = -diffbegv;
 /* But also implement a heuristic that favors the known region --
 	 see above. */
 diffbegv += heuristic_hack;
 diffpt += heuristic_hack;
 if (diffpt < diffmin && diffpt <= diffbegv)
 	{
 forward_p = 1;
 while (x > bufmax)
 	{
 	  newmax = bytmax;
 	  INC_BYTIND (buf, newmax);
 	  newsize = newmax - bytmax;
 	  if (newsize != size)
 	    {
 	      bufmin = bufmax;
 forward_p = 0;
 while (x < bufmin)
 	{
 	  newmin = bytmin;
 	  DEC_BYTIND (buf, newmin);
 	  newsize = bytmin - newmin;
 	  if (newsize != size)
 	    {
 	      bufmax = bufmin;
 /* #### This value could stand some more exploration. */
 Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
 /* Check if the position is closer to PT or ZV than to the
 	 end of the known region. */
 if (diffpt < 0)
 	diffpt = -diffpt;
 if (diffzv < 0)
 	diffzv = -diffzv;
 	 over BI_PT or BI_ZV.  The reason for this is that switching to
 	 BI_PT or BI_ZV will wipe out the knowledge in the known region,
 	 which might be annoying if the known region is large and
 	 BI_PT or BI_ZV is not that much closer than the end of the known
 	 region. */
 diffzv += heuristic_hack;
 diffpt += heuristic_hack;
 if (diffpt < diffmax && diffpt <= diffzv)
 	{
 	  bufmax = bufmin = BUF_PT (buf);
 if (diffbegv < 0)
 	diffbegv = -diffbegv;
 /* But also implement a heuristic that favors the known region --
 	 see above. */
 diffbegv += heuristic_hack;
 diffpt += heuristic_hack;
 if (diffpt < diffmin && diffpt <= diffbegv)
 	{
 forward_p = 1;
 while (x > bytmax)
 	{
 	  newmax = bytmax;
 	  INC_BYTIND (buf, newmax);
 	  newsize = newmax - bytmax;
 	  if (newsize != size)
 	    {
 	      bufmin = bufmax;
 forward_p = 0;
 while (x < bytmin)
 	{
 	  newmin = bytmin;
 	  DEC_BYTIND (buf, newmin);
 	  newsize = bytmin - newmin;
 	  if (newsize != size)
 	    {
 	      bufmax = bufmin;
 int i;
 /* Adjust the cache of known positions. */
 for (i = 0; i < 16; i++)
 {
 if (buf->text->mule_bufpos_cache[i] > start)
 	{
 	  buf->text->mule_bufpos_cache[i] += charlength;
 	  buf->text->mule_bytind_cache[i] += bytelength;
 	}
 CHECK_INT_COERCE_MARKER (pos);
 ind = XINT (pos);
 min_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_BEG (b) : BUF_BEGV (b);
 max_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_Z   (b) : BUF_ZV   (b);
 if (ind < min_allowed || ind > max_allowed)
 {
 if (flags & GB_COERCE_RANGE)
 	ind = ind < min_allowed ? min_allowed : max_allowed;
 else if (flags & GB_NO_ERROR_IF_BAD)
 	mpos = from + amount;
 }
 if (mpos > from && mpos <= to)
 mpos += amount;
 return mpos;
 }
 /* Do the following:
 (1) Add `amount' to the position of every marker in the current buffer
 whose current position is between `from' (exclusive) and `to' (inclusive).
 or when a region of characters adjacent to the gap is wiped out,
 causing the gap to increase to include the region (in this case,
 `from' and `to' are the same, both pointing to the boundary
 between the gap and the deleted region, and there are no markers
 affected by (1)).
 The reason for the use of exclusive and inclusive is that markers at
 the gap always sit at the beginning, not at the end.
 */
 static void
 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + BUF_END_GAP_SIZE (buf));
 SET_BUF_END_GAP_SIZE (buf, 0);
 SET_END_SENTINEL (buf);
 }
 QUIT;
 }
 /* Move gap to position `pos'.
 Note that this can quit!  */
 Bytecount old_gap_size;
 Bytecount increment;
 increment = BUF_END_GAP_SIZE (buf);
 SET_BUF_END_GAP_SIZE (buf, 0);
 if (increment > 0)
 {
 /* Prevent quitting in move_gap.  */
 tem = Vinhibit_quit;
 Vinhibit_quit = Qt;
 if (increment > BUF_END_GAP_SIZE (buf))
 {
 /* Don't allow a buffer size that won't fit in an int
 	 even if it will fit in a Lisp integer.
 	 That won't work because so many places use `int'.  */
 if (BUF_Z (buf) - BUF_BEG (buf) + BUF_GAP_SIZE (buf) + increment
 	  >= ((unsigned) 1 << (min (INTBITS, VALBITS) - 1)))
 	error ("Buffer exceeds maximum size");
 result = BUFFER_REALLOC (buf->text->beg,
 			       BI_BUF_Z (buf) - BI_BUF_BEG (buf) +
 			       BUF_GAP_SIZE (buf) + increment +
 			       BUF_END_SENTINEL_SIZE);
 if (result == 0)
 	memory_full ();
 SET_BUF_BEG_ADDR (buf, result);
 }
 else
 increment = BUF_END_GAP_SIZE (buf);
 /* Prevent quitting in move_gap.  */
 tem = Vinhibit_quit;
 Vinhibit_quit = Qt;
 real_gap_loc = BI_BUF_GPT (buf);
 static void
 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
 		     Bufpos new_end);
 /* Call the after-change-functions according to the changes made so far
 and treat all further changes as single until the outermost
 multiple change exits.  This is called when the outermost multiple
 change exits and when someone is trying to make a change that violates
 the constraints specified in begin_multiple_change(), typically
 automatically, however, and if changes somehow or other happen outside
 of the specified region, that will also be handled correctly.
 begin_multiple_change() returns a number (actually a specpdl depth)
 that you must pass to end_multiple_change() when you are done. */
 int
 begin_multiple_change (struct buffer *buf, Bufpos start, Bufpos end)
 {
 /* This function can GC */
 int count = -1;
 #endif
 /* Make sure that point-max won't exceed the size of an emacs int. */
 {
 Lisp_Object temp;
 XSETINT (temp, (int) (length + BUF_Z (buf)));
 if ((int) (length + BUF_Z (buf)) != XINT (temp))
 error ("maximum buffer size exceeded");
 }
 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);
 }
 {
 /* This function can GC */
 return buffer_insert_emacs_char_1 (buf, pos, (Emchar) (unsigned char) c,
 				     flags);
 }
 Charcount
 buffer_insert_from_buffer_1 (struct buffer *buf, Bufpos pos,
 			     struct buffer *buf2, Bufpos pos2,
 			     Charcount length, int flags)
 {
 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);
 BUF_MODIFF (buf)++;
 MARK_BUFFERS_CHANGED;
-/* Relocate point as if it were a marker.  */
+/* ### Point used to be modified here, but this causes problems with MULE,
-if (bi_from < BI_BUF_PT (buf))
+	 as point is used to calculate bytinds, and if the offset in bc_numdel causes
-	{
+	 point to move to a non first-byte location, causing some other function to
-	  if (BI_BUF_PT (buf) < bi_to)
+	 throw an assertion in ASSERT_VALID_BYTIND. I've moved the code to right after
-	    JUST_SET_POINT (buf, from, bi_from);
+	  the other movements and adjustments, but before the gap is moved.
-	  else
+	  -- jh 970813 */
-	    JUST_SET_POINT (buf, BUF_PT (buf) - numdel,
-			    BI_BUF_PT (buf) - bc_numdel);
-	}
 /* 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
 		      (- bc_numdel));
 /* Relocate any extent endpoints just like markers. */
 adjust_extents_for_deletion (bufobj, bi_from, bi_to,
 				   BUF_GAP_SIZE (buf), bc_numdel, 0);
+/* Relocate point as if it were a marker.  */
+if (bi_from < BI_BUF_PT (buf))
+	{
+	  if (BI_BUF_PT (buf) < bi_to)
+	    JUST_SET_POINT (buf, from, bi_from);
+	  else
+	    JUST_SET_POINT (buf, BUF_PT (buf) - numdel,
+			    BI_BUF_PT (buf) - 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);
 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
 SET_GAP_SENTINEL (buf);
 }
 else
 BUF_MODIFF (buf)++;
 MARK_BUFFERS_CHANGED;
 /* ### Point used to be modified here, but this causes problems with MULE,
 	 as point is used to calculate bytinds, and if the offset in bc_numdel causes
 	 point to move to a non first-byte location, causing some other function to
 	 throw an assertion in ASSERT_VALID_BYTIND. I've moved the code to right after
 	  the other movements and adjustments, but before the gap is moved.
 	  -- jh 970813 */
 /* Detach any extents that are completely within the range [FROM, TO],
 {
 int cols = 0;
 int i;
 for (i = 0; i < len; i++)
 cols += XCHARSET_COLUMNS (CHAR_CHARSET (str[i]));
 return cols;
 }
 /* NOTE: Does not reset the Dynarr. */
 void
 convert_bufbyte_string_into_emchar_dynarr (CONST Bufbyte *str, Bytecount len,
-					   emchar_dynarr *dyn)
+					   Emchar_dynarr *dyn)
 {
 CONST Bufbyte *strend = str + len;
 while (str < strend)
 {
 Store into the given Bufbyte dynarr.  Does not reset the dynarr.
 Does not add a terminating zero. */
 void
 convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
-					  bufbyte_dynarr *dyn)
+					  Bufbyte_dynarr *dyn)
 {
 Bufbyte str[MAX_EMCHAR_LEN];
 int i;
 for (i = 0; i < nels; i++)
 {
 /* Damn zero-termination. */
 Bufbyte *str = (Bufbyte *) alloca (nels * MAX_EMCHAR_LEN + 1);
 Bufbyte *strorig = str;
 Bytecount len;
 int i;
 for (i = 0; i < nels; i++)
 str += set_charptr_emchar (str, arr[i]);
 *str = '\0';
 len = str - strorig;
-str = xmalloc (1 + len);
+str = (Bufbyte *) xmalloc (1 + len);
 memcpy (str, strorig, 1 + len);
 if (len_out)
 *len_out = len;
 return str;
 }
 SET_GAP_SENTINEL (b);
 SET_END_SENTINEL (b);
 #ifdef MULE
 {
 	int i;
 	b->text->mule_bufmin = b->text->mule_bufmax = 1;
 	b->text->mule_bytmin = b->text->mule_bytmax = 1;
 	b->text->mule_shifter = 0;
 	b->text->mule_three_p = 0;
 	for (i = 0; i < 16; i++)
 	  {
 	    b->text->mule_bufpos_cache[i] = 1;
 	    b->text->mule_bytind_cache[i] = 1;
 	  }
 JUST_SET_POINT (b, 1, 1);
 SET_BOTH_BUF_BEGV (b, 1, 1);
 SET_BOTH_BUF_ZV (b, 1, 1);
-b->text->changes =
+b->text->changes = xnew_and_zero (struct buffer_text_change_data);
-	(struct buffer_text_change_data *)
-	  xmalloc (sizeof (*b->text->changes));
-memset (b->text->changes, 0, sizeof (*b->text->changes));
 }
 else
 {
 JUST_SET_POINT (b, BUF_PT (b->base_buffer), BI_BUF_PT (b->base_buffer));
 SET_BOTH_BUF_BEGV (b, BUF_BEGV (b->base_buffer),
 			 BI_BUF_BEGV (b->base_buffer));
 SET_BOTH_BUF_ZV (b, BUF_ZV (b->base_buffer),
 			 BI_BUF_ZV (b->base_buffer));
 }
-b->changes =
+b->changes = xnew_and_zero (struct each_buffer_change_data);
-(struct each_buffer_change_data *) xmalloc (sizeof (*b->changes));
-memset (b->changes, 0, sizeof (*b->changes));
 BUF_FACECHANGE (b) = 1;
 #ifdef REGION_CACHE_NEEDS_WORK
 b->newline_cache = 0;
 b->width_run_cache = 0;

Mercurial > hg > xemacs-beta

comparison src/insdel.c @ 185:3d6bfa290dbd r20-3b19