comparison src/insdel.c @ 21136:be04baf3d970

(adjust_markers_for_insert): Don't leave a marker within the combined_after_bytes. Use DEC than INC when leaving a marker before the insertion. (count_combining_before): Return number of bytes from start of insertion that will combine. (insert_1_both): Compensate for change in count_combining_before. Delete intervals for the combined_after_bytes. Compensate for that when updating other intervals. (insert_from_buffer_1, replace_range): Likewise. (adjust_after_replace): Likewise. (insert_from_string_1): Likewise. Also handle intervals for inserting just part of string.

21135:42badfae3618


/* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
   to TO / TO_BYTE.  We have to relocate the charpos of every marker
   that points after the insertion (but not their bytepos).

   COMBINED_BEFORE_BYTES is the number of bytes before the insertion
   that combines into one character with the first inserted bytes.
   COMBINED_AFTER_BYTES is the number of bytes after the insertion
   that combines into one character with the last inserted bytes.

   When a marker points at the insertion point,
   we advance it if either its insertion-type is t
   or BEFORE_MARKERS is true.  */

	    {
	      /* This marker doesn't "need relocation",
		 but don't leave it pointing in the middle of a character.
		 Point the marker after the combined character,
		 so that undoing the insertion puts it back where it was.  */
	      m->bytepos -= combined_before_bytes;
	      m->charpos -= 1;
	      INC_BOTH (m->charpos, m->bytepos);
	    }
	}
      else if (m->bytepos > from_byte)
	{
	  m->bytepos += nbytes;
	  m->charpos += nchars;

		 inherit, prepare, before_markers);
}

/* See if the bytes before POS/POS_BYTE combine with bytes
   at the start of STRING to form a single character.
   If so, return the number of bytes before POS/POS_BYTE
   which combine in this way.  Otherwise, return 0.  */

int
count_combining_before (string, length, pos, pos_byte)
     unsigned char *string;
     int length;
     int pos, pos_byte;
{
  int opos = pos, opos_byte = pos_byte;
  int c;

  if (NILP (current_buffer->enable_multibyte_characters))
    return 0;
  if (length == 0 || CHAR_HEAD_P (*string))
    return 0;

    return 0;
  DEC_BOTH (pos, pos_byte);
  c = FETCH_BYTE (pos_byte);
  if (! BASE_LEADING_CODE_P (c))
    return 0;
  return opos_byte - pos_byte;
}

/* See if the bytes after POS/POS_BYTE combine with bytes
   at the end of STRING to form a single character.
   If so, return the number of bytes after POS/POS_BYTE

  combined_before_bytes = count_combining_before (string, nbytes, PT, PT_BYTE);
  combined_after_bytes = count_combining_after (string, nbytes, PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */
  /* The combined bytes before all count as one character, because
     they start with a leading code, but the combined bytes after
     count as separate characters, because they are all trailing codes.  */

  adjusted_nchars = nchars - !!combined_before_bytes - combined_after_bytes;

  if (prepare)
    prepare_to_modify_buffer (PT - !!combined_before_bytes,
			      PT + combined_after_bytes,
			      NULL);

    /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES.  */
    offset_intervals (current_buffer, PT, adjusted_nchars);
#endif

  GAP_SIZE -= nbytes;
  GPT += nchars - !! combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_nchars;
  Z += adjusted_nchars;
  GPT_BYTE += nbytes;
  ZV_BYTE += nbytes;
  Z_BYTE += nbytes;

  adjust_overlays_for_insert (PT, adjusted_nchars);
  adjust_markers_for_insert (PT, PT_BYTE,
			     PT + adjusted_nchars, PT_BYTE + nbytes,
			     combined_before_bytes, combined_after_bytes,
			     before_markers);
  adjust_point (adjusted_nchars + combined_after_bytes,
		nbytes + combined_after_bytes);

  if (combined_after_bytes)
    move_gap_both (GPT + 1, GPT_BYTE + combined_after_bytes);

  if (GPT_BYTE < GPT)
    abort ();

#ifdef USE_TEXT_PROPERTIES
  if (!inherit && BUF_INTERVALS (current_buffer) != 0)
    Fset_text_properties (make_number (PT - adjusted_nchars), make_number (PT),
			  Qnil, Qnil);
#endif
}

/* Insert the part of the text of STRING, a Lisp object assumed to be
   of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
   starting at position POS / POS_BYTE.  If the text of STRING has properties,

  register Lisp_Object temp;
  struct gcpro gcpro1;
  int outgoing_nbytes = nbytes;
  int combined_before_bytes, combined_after_bytes;
  int adjusted_nchars;

  /* Make OUTGOING_NBYTES describe the text
     as it will be inserted in this buffer.  */

  if (NILP (current_buffer->enable_multibyte_characters))

  combined_after_bytes
    = count_combining_after (XSTRING (string)->data + pos_byte, nbytes,
			     PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */
  adjusted_nchars = nchars - !!combined_before_bytes - combined_after_bytes;

  /* Record deletion of the surrounding text that combines with
     the insertion.  This, together with recording the insertion,
     will add up to the right stuff in the undo list.

  /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
  offset_intervals (current_buffer, PT, adjusted_nchars);

  GAP_SIZE -= outgoing_nbytes;
  GPT += nchars - !!combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_nchars;
  Z += adjusted_nchars;
  GPT_BYTE += outgoing_nbytes;
  ZV_BYTE += outgoing_nbytes;
  Z_BYTE += outgoing_nbytes;

    move_gap_both (GPT + 1, GPT_BYTE + combined_after_bytes);

  if (GPT_BYTE < GPT)
    abort ();

  graft_intervals_into_buffer (XSTRING (string)->intervals, PT, nchars,
			       current_buffer, inherit);
  adjust_point (adjusted_nchars + combined_after_bytes,
		outgoing_nbytes + combined_after_bytes);
}

/* Insert text from BUF, NCHARS characters starting at CHARPOS, into the

  int to_byte = buf_charpos_to_bytepos (buf, from + nchars);
  int incoming_nbytes = to_byte - from_byte;
  int outgoing_nbytes = incoming_nbytes;
  int combined_before_bytes, combined_after_bytes;
  int adjusted_nchars;

  /* Make OUTGOING_NBYTES describe the text
     as it will be inserted in this buffer.  */

  if (NILP (current_buffer->enable_multibyte_characters))

  combined_after_bytes
    = count_combining_after (PT_ADDR, outgoing_nbytes,
			     PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */
  adjusted_nchars = nchars - !!combined_before_bytes - combined_after_bytes;

  /* Record deletion of the surrounding text that combines with
     the insertion.  This, together with recording the insertion,
     will add up to the right stuff in the undo list.

  if (BUF_INTERVALS (current_buffer) != 0)
    offset_intervals (current_buffer, PT, adjusted_nchars);
#endif

  GAP_SIZE -= outgoing_nbytes;
  GPT += nchars - !!combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_nchars;
  Z += adjusted_nchars;
  GPT_BYTE += outgoing_nbytes;
  ZV_BYTE += outgoing_nbytes;
  Z_BYTE += outgoing_nbytes;
  if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor.  */
  adjust_overlays_for_insert (PT, adjusted_nchars);
  adjust_markers_for_insert (PT, PT_BYTE, PT + adjusted_nchars,
			     PT_BYTE + outgoing_nbytes,
			     combined_before_bytes, combined_after_bytes, 0);
  adjust_point (adjusted_nchars + combined_after_bytes,
		outgoing_nbytes + combined_after_bytes);

  if (combined_after_bytes)
    move_gap_both (GPT + 1, GPT_BYTE + combined_after_bytes);

  if (GPT_BYTE < GPT)
    abort ();

  /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
  graft_intervals_into_buffer (copy_intervals (BUF_INTERVALS (buf),
					       from, nchars),
			       PT - adjusted_nchars, adjusted_nchars,
			       current_buffer, inherit);
}

/* This function should be called after moving gap to FROM and before
   altering text between FROM and TO.  This adjusts various position
   keepers and markers as if the text is deleted.  Don't forget to

adjust_after_replace (from, from_byte, to, to_byte, len, len_byte,
		      combined_before_bytes, combined_after_bytes)
     int from, from_byte, to, to_byte, len, len_byte;
     int combined_before_bytes, combined_after_bytes;
{
  int adjusted_nchars = len - !!combined_before_bytes - combined_after_bytes;
  record_insert (from - !!combined_before_bytes, len);
  if (from < PT)
    adjust_point (len - (to - from) + combined_after_bytes,
		  len_byte - (to_byte - from_byte) + combined_after_bytes);
#ifdef USE_TEXT_PROPERTIES

  int nbytes_del, nchars_del;
  register Lisp_Object temp;
  struct gcpro gcpro1;
  int combined_before_bytes, combined_after_bytes;
  int adjusted_inschars;

  GCPRO1 (new);

  if (prepare)
    {

  combined_after_bytes
    = count_combining_after (XSTRING (new)->data, insbytes, PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */
  adjusted_inschars
    = inschars - !!combined_before_bytes - combined_after_bytes;

  /* Record deletion of the surrounding text that combines with
     the insertion.  This, together with recording the insertion,
     will add up to the right stuff in the undo list.

#ifdef USE_TEXT_PROPERTIES
  offset_intervals (current_buffer, PT, adjusted_inschars - nchars_del);
#endif

  GAP_SIZE -= insbytes;
  GPT += inschars - !!combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_inschars;
  Z += adjusted_inschars;
  GPT_BYTE += insbytes;
  ZV_BYTE += insbytes;
  ZV_BYTE += insbytes;

  adjust_overlays_for_insert (from, adjusted_inschars);
  adjust_markers_for_insert (from, from_byte, from + adjusted_inschars,
			     from_byte + insbytes,
			     combined_before_bytes, combined_after_bytes, 0);

#ifdef USE_TEXT_PROPERTIES
  /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
  graft_intervals_into_buffer (XSTRING (new)->intervals, from,
			       inschars, current_buffer, inherit);
#endif

  if (insbytes == 0)
    evaporate_overlays (from);

  if (combined_after_bytes)

21136:be04baf3d970


/* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
   to TO / TO_BYTE.  We have to relocate the charpos of every marker
   that points after the insertion (but not their bytepos).

   COMBINED_BEFORE_BYTES is the number of bytes at the start of the insertion
   that combine into one character with the text before the insertion.
   COMBINED_AFTER_BYTES is the number of bytes after the insertion
   that combine into one character with the last inserted bytes.

   When a marker points at the insertion point,
   we advance it if either its insertion-type is t
   or BEFORE_MARKERS is true.  */

	    {
	      /* This marker doesn't "need relocation",
		 but don't leave it pointing in the middle of a character.
		 Point the marker after the combined character,
		 so that undoing the insertion puts it back where it was.  */

	      /* Here we depend on the fact that the gap is after
		 all of the combining bytes that we are going to skip over.  */
	      DEC_BOTH (m->charpos, m->bytepos);
	      INC_BOTH (m->charpos, m->bytepos);
	    }
	}
      /* If a marker was pointing into the combining bytes
	 after the insertion, don't leave it there
	 in the middle of a character.  */
      else if (combined_after_bytes && m->bytepos >= from_byte
	       && m->bytepos < from_byte + combined_after_bytes)
	{
	  /* Put it after the combining bytes.  */
	  m->bytepos = to_byte + combined_after_bytes;
	  m->charpos = to + 1;
	  /* Now move it back before the combined character,
	     so that undoing the insertion will put it where it was.  */
	  DEC_BOTH (m->charpos, m->bytepos);
	}
      else if (m->bytepos > from_byte)
	{
	  m->bytepos += nbytes;
	  m->charpos += nchars;

		 inherit, prepare, before_markers);
}

/* See if the bytes before POS/POS_BYTE combine with bytes
   at the start of STRING to form a single character.
   If so, return the number of bytes at the start of STRING
   which combine in this way.  Otherwise, return 0.  */

int
count_combining_before (string, length, pos, pos_byte)
     unsigned char *string;
     int length;
     int pos, pos_byte;
{
  int opos = pos, opos_byte = pos_byte;
  int c;
  unsigned char *p = string;

  if (NILP (current_buffer->enable_multibyte_characters))
    return 0;
  if (length == 0 || CHAR_HEAD_P (*string))
    return 0;

    return 0;
  DEC_BOTH (pos, pos_byte);
  c = FETCH_BYTE (pos_byte);
  if (! BASE_LEADING_CODE_P (c))
    return 0;

  /* We have a combination situation.
     Count the bytes at STRING that will combine.  */
  while (!CHAR_HEAD_P (*p) && p < string + length)
    p++;

  return p - string;
}

/* See if the bytes after POS/POS_BYTE combine with bytes
   at the end of STRING to form a single character.
   If so, return the number of bytes after POS/POS_BYTE

  combined_before_bytes = count_combining_before (string, nbytes, PT, PT_BYTE);
  combined_after_bytes = count_combining_after (string, nbytes, PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */

  adjusted_nchars = nchars - combined_before_bytes - combined_after_bytes;

  if (prepare)
    prepare_to_modify_buffer (PT - !!combined_before_bytes,
			      PT + combined_after_bytes,
			      NULL);

    /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES.  */
    offset_intervals (current_buffer, PT, adjusted_nchars);
#endif

  GAP_SIZE -= nbytes;
  /* When we have combining at the end of the insertion,
     this is the character position before the combined character.  */
  GPT += nchars - combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_nchars;
  Z += adjusted_nchars;
  GPT_BYTE += nbytes;
  ZV_BYTE += nbytes;
  Z_BYTE += nbytes;

  adjust_overlays_for_insert (PT, adjusted_nchars);
  adjust_markers_for_insert (PT, PT_BYTE,
			     PT + adjusted_nchars, PT_BYTE + nbytes,
			     combined_before_bytes, combined_after_bytes,
			     before_markers);

  /* "Delete" the combined-after bytes, as far as intervals are concerned.
     Note that as far as the intervals are concerned,
     no insertion has yet taken place, so these bytes are right after PT.  */
  if (combined_after_bytes)
    offset_intervals (current_buffer, PT, - combined_after_bytes);

#ifdef USE_TEXT_PROPERTIES
  if (!inherit && BUF_INTERVALS (current_buffer) != 0)
    Fset_text_properties (make_number (PT),
			  make_number (PT + adjusted_nchars + combined_after_bytes),
			  Qnil, Qnil);
#endif

  adjust_point (adjusted_nchars + combined_after_bytes,
		nbytes + combined_after_bytes);

  if (combined_after_bytes)
    move_gap_both (GPT + 1, GPT_BYTE + combined_after_bytes);

  if (GPT_BYTE < GPT)
    abort ();
}

/* Insert the part of the text of STRING, a Lisp object assumed to be
   of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
   starting at position POS / POS_BYTE.  If the text of STRING has properties,

  register Lisp_Object temp;
  struct gcpro gcpro1;
  int outgoing_nbytes = nbytes;
  int combined_before_bytes, combined_after_bytes;
  int adjusted_nchars;
  INTERVAL intervals;

  /* Make OUTGOING_NBYTES describe the text
     as it will be inserted in this buffer.  */

  if (NILP (current_buffer->enable_multibyte_characters))

  combined_after_bytes
    = count_combining_after (XSTRING (string)->data + pos_byte, nbytes,
			     PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */
  adjusted_nchars = nchars - combined_before_bytes - combined_after_bytes;

  /* Record deletion of the surrounding text that combines with
     the insertion.  This, together with recording the insertion,
     will add up to the right stuff in the undo list.

  /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
  offset_intervals (current_buffer, PT, adjusted_nchars);

  GAP_SIZE -= outgoing_nbytes;
  GPT += nchars - combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_nchars;
  Z += adjusted_nchars;
  GPT_BYTE += outgoing_nbytes;
  ZV_BYTE += outgoing_nbytes;
  Z_BYTE += outgoing_nbytes;

    move_gap_both (GPT + 1, GPT_BYTE + combined_after_bytes);

  if (GPT_BYTE < GPT)
    abort ();

  /* "Delete" the combined-after bytes, as far as intervals are concerned.
     Note that as far as the intervals are concerned,
     no insertion has yet taken place, so these bytes are right after PT.  */
  if (combined_after_bytes)
    offset_intervals (current_buffer, PT, - combined_after_bytes);

  /* Get the intervals for the part of the string we are inserting--
     not including the combined-before bytes.  */
  intervals = XSTRING (string)->intervals;
  if (combined_before_bytes != 0
      || nbytes < XSTRING (string)->size_byte)
    intervals = copy_intervals (intervals, pos + combined_before_bytes,
				nchars - combined_before_bytes);
			       
  /* Insert those intervals.  */
  graft_intervals_into_buffer (intervals, PT, nchars - combined_before_bytes,
			       current_buffer, inherit);

  adjust_point (adjusted_nchars + combined_after_bytes,
		outgoing_nbytes + combined_after_bytes);
}

/* Insert text from BUF, NCHARS characters starting at CHARPOS, into the

  int to_byte = buf_charpos_to_bytepos (buf, from + nchars);
  int incoming_nbytes = to_byte - from_byte;
  int outgoing_nbytes = incoming_nbytes;
  int combined_before_bytes, combined_after_bytes;
  int adjusted_nchars;
  INTERVAL intervals;

  /* Make OUTGOING_NBYTES describe the text
     as it will be inserted in this buffer.  */

  if (NILP (current_buffer->enable_multibyte_characters))

  combined_after_bytes
    = count_combining_after (PT_ADDR, outgoing_nbytes,
			     PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */
  adjusted_nchars = nchars - combined_before_bytes - combined_after_bytes;

  /* Record deletion of the surrounding text that combines with
     the insertion.  This, together with recording the insertion,
     will add up to the right stuff in the undo list.

  if (BUF_INTERVALS (current_buffer) != 0)
    offset_intervals (current_buffer, PT, adjusted_nchars);
#endif

  GAP_SIZE -= outgoing_nbytes;
  GPT += nchars - combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_nchars;
  Z += adjusted_nchars;
  GPT_BYTE += outgoing_nbytes;
  ZV_BYTE += outgoing_nbytes;
  Z_BYTE += outgoing_nbytes;
  if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor.  */
  adjust_overlays_for_insert (PT, adjusted_nchars);
  adjust_markers_for_insert (PT, PT_BYTE, PT + adjusted_nchars,
			     PT_BYTE + outgoing_nbytes,
			     combined_before_bytes, combined_after_bytes, 0);

  /* "Delete" the combined-after bytes, as far as intervals are concerned.
     Note that as far as the intervals are concerned,
     no insertion has yet taken place, so these bytes are right after PT.  */
  if (combined_after_bytes)
    offset_intervals (current_buffer, PT, - combined_after_bytes);

  /* Get the intervals for the part of the string we are inserting--
     not including the combined-before bytes.  */
  intervals = BUF_INTERVALS (buf);
  if (combined_before_bytes != 0
      || nbytes < BUF_Z_BYTE (buf) - BUF_BEG_BYTE (buf))
    intervals = copy_intervals (intervals, from + combined_before_bytes,
				nchars - combined_before_bytes);
			       
  /* Insert those intervals.  */
  graft_intervals_into_buffer (intervals, PT, nchars - combined_before_bytes,
			       current_buffer, inherit);


  adjust_point (adjusted_nchars + combined_after_bytes,
		outgoing_nbytes + combined_after_bytes);

  if (combined_after_bytes)
    move_gap_both (GPT + 1, GPT_BYTE + combined_after_bytes);

  if (GPT_BYTE < GPT)
    abort ();
}

/* This function should be called after moving gap to FROM and before
   altering text between FROM and TO.  This adjusts various position
   keepers and markers as if the text is deleted.  Don't forget to

adjust_after_replace (from, from_byte, to, to_byte, len, len_byte,
		      combined_before_bytes, combined_after_bytes)
     int from, from_byte, to, to_byte, len, len_byte;
     int combined_before_bytes, combined_after_bytes;
{
  int adjusted_nchars = len - combined_before_bytes - combined_after_bytes;
  record_insert (from - !!combined_before_bytes, len);
  if (from < PT)
    adjust_point (len - (to - from) + combined_after_bytes,
		  len_byte - (to_byte - from_byte) + combined_after_bytes);
#ifdef USE_TEXT_PROPERTIES

  int nbytes_del, nchars_del;
  register Lisp_Object temp;
  struct gcpro gcpro1;
  int combined_before_bytes, combined_after_bytes;
  int adjusted_inschars;
  INTERVAL intervals;

  GCPRO1 (new);

  if (prepare)
    {

  combined_after_bytes
    = count_combining_after (XSTRING (new)->data, insbytes, PT, PT_BYTE);

  /* This is the net amount that Z will increase from this insertion.  */
  adjusted_inschars
    = inschars - combined_before_bytes - combined_after_bytes;

  /* Record deletion of the surrounding text that combines with
     the insertion.  This, together with recording the insertion,
     will add up to the right stuff in the undo list.

#ifdef USE_TEXT_PROPERTIES
  offset_intervals (current_buffer, PT, adjusted_inschars - nchars_del);
#endif

  GAP_SIZE -= insbytes;
  GPT += inschars - combined_before_bytes - !!combined_after_bytes;
  ZV += adjusted_inschars;
  Z += adjusted_inschars;
  GPT_BYTE += insbytes;
  ZV_BYTE += insbytes;
  ZV_BYTE += insbytes;

  adjust_overlays_for_insert (from, adjusted_inschars);
  adjust_markers_for_insert (from, from_byte, from + adjusted_inschars,
			     from_byte + insbytes,
			     combined_before_bytes, combined_after_bytes, 0);

  /* "Delete" the combined-after bytes, as far as intervals are concerned.
     Note that as far as the intervals are concerned,
     no insertion has yet taken place, so these bytes are right after PT.  */
  if (combined_after_bytes)
    offset_intervals (current_buffer, PT, - combined_after_bytes);

  /* Get the intervals for the part of the string we are inserting--
     not including the combined-before bytes.  */
  intervals = XSTRING (new)->intervals;
  if (combined_before_bytes != 0)
    intervals = copy_intervals (intervals, combined_before_bytes,
				inschars - combined_before_bytes);
			       
  /* Insert those intervals.  */
  graft_intervals_into_buffer (intervals, from,
			       inschars - combined_before_bytes,
			       current_buffer, inherit);

  if (insbytes == 0)
    evaporate_overlays (from);

  if (combined_after_bytes)