emacs: src/editfns.c comparison

comparison src/editfns.c @ 21245:6cde55b7c9de

Use STRING_BYTES and SET_STRING_BYTES. (Ftranspose_regions): Try to handle combining bytes.

author	Richard M. Stallman <rms@gnu.org>
date	Sat, 21 Mar 1998 07:06:55 +0000
parents	eba3d61855d0
children	205a5aa4aa2f

comparison

equal deleted inserted replaced

-:50929073a0ba
+:6cde55b7c9de
 register Lisp_Object val;
 register struct Lisp_String *p;
 CHECK_STRING (string, 0);
 p = XSTRING (string);
 if (p->size)
-XSETFASTINT (val, STRING_CHAR (p->data, p->size_byte));
+XSETFASTINT (val, STRING_CHAR (p->data, STRING_BYTES (p)));
 else
 XSETFASTINT (val, 0);
 return val;
 }
 if (! lisp_time_argument (time, &value))
 error ("Invalid time specification");
 /* This is probably enough.  */
-size = XSTRING (format_string)->size_byte * 6 + 50;
+size = STRING_BYTES (XSTRING (format_string)) * 6 + 50;
 while (1)
 {
 char *buf = (char *) alloca (size + 1);
 int result;
 	}
 else if (STRINGP (val))
 	{
 	  (*insert_from_string_func) (val, 0, 0,
 				      XSTRING (val)->size,
-				      XSTRING (val)->size_byte,
+				      STRING_BYTES (XSTRING (val)),
 				      inherit);
 	}
 else
 	{
 	  val = wrong_type_argument (Qchar_or_string_p, val);
 int pos;
 validate_region (&start, &end);
 CHECK_STRING (table, 2);
-size = XSTRING (table)->size_byte;
+size = STRING_BYTES (XSTRING (table));
 tt = XSTRING (table)->data;
 pos_byte = CHAR_TO_BYTE (XINT (start));
 stop = CHAR_TO_BYTE (XINT (end));
 modify_region (current_buffer, XINT (start), XINT (end));
 if (! message_text)
 	{
 	  message_text = (char *)xmalloc (80);
 	  message_length = 80;
 	}
-if (XSTRING (val)->size_byte > message_length)
+if (STRING_BYTES (XSTRING (val)) > message_length)
 	{
-	  message_length = XSTRING (val)->size_byte;
+	  message_length = STRING_BYTES (XSTRING (val));
 	  message_text = (char *)xrealloc (message_text, message_length);
 	}
-bcopy (XSTRING (val)->data, message_text, XSTRING (val)->size_byte);
+bcopy (XSTRING (val)->data, message_text, STRING_BYTES (XSTRING (val)));
-message2 (message_text, XSTRING (val)->size_byte,
+message2 (message_text, STRING_BYTES (XSTRING (val)),
 		STRING_MULTIBYTE (val));
 return val;
 }
 }
 if (! message_text)
 	{
 	  message_text = (char *)xmalloc (80);
 	  message_length = 80;
 	}
-if (XSTRING (val)->size_byte > message_length)
+if (STRING_BYTES (XSTRING (val)) > message_length)
 	{
-	  message_length = XSTRING (val)->size_byte;
+	  message_length = STRING_BYTES (XSTRING (val));
 	  message_text = (char *)xrealloc (message_text, message_length);
 	}
-bcopy (XSTRING (val)->data, message_text, XSTRING (val)->size_byte);
+bcopy (XSTRING (val)->data, message_text, STRING_BYTES (XSTRING (val)));
-message2 (message_text, XSTRING (val)->size_byte);
+message2 (message_text, STRING_BYTES (XSTRING (val)));
 return val;
 #endif /* not HAVE_MENUS */
 }
 }
 #ifdef HAVE_MENUS
 MULTIBYTE is nonzero if the result should be multibyte.  */
 #define CONVERTED_BYTE_SIZE(MULTIBYTE, STRING)				\
 (((MULTIBYTE) && ! STRING_MULTIBYTE (STRING))				\
 ? count_size_as_multibyte (XSTRING (STRING)->data,			\
-			      XSTRING (STRING)->size_byte)		\
+			      STRING_BYTES (XSTRING (STRING)))		\
-: XSTRING (STRING)->size_byte)
+: STRING_BYTES (XSTRING (STRING)))
 DEFUN ("format", Fformat, Sformat, 1, MANY, 0,
 "Format a string out of a control-string and arguments.\n\
 The first argument is a control string.\n\
 The other arguments are substituted into it to make the result, a string.\n\
 /* If we start out planning a unibyte result,
 and later find it has to be multibyte, we jump back to retry.  */
 retry:
 format = XSTRING (args[0])->data;
-end = format + XSTRING (args[0])->size_byte;
+end = format + STRING_BYTES (XSTRING (args[0]));
 longest_format = 0;
 /* Make room in result for all the non-%-codes in the control string.  */
 total = 5 + CONVERTED_BYTE_SIZE (multibyte, args[0]);
 		  {
 		    multibyte = 1;
 		    goto retry;
 		  }
 		args[n] = Fchar_to_string (args[n]);
-		thissize = XSTRING (args[n])->size_byte;
+		thissize = STRING_BYTES (XSTRING (args[n]));
 	      }
 	  }
 #ifdef LISP_FLOAT_TYPE
 	else if (FLOATP (args[n]) && *format != 's')
 	  {
 	  if (STRINGP (args[n]))
 	    {
 	      int padding, nbytes;
 	      int width = strwidth (XSTRING (args[n])->data,
-				    XSTRING (args[n])->size_byte);
+				    STRING_BYTES (XSTRING (args[n])));
 	      /* If spec requires it, pad on right with spaces.  */
 	      padding = minlen - width;
 	      if (! negative)
 		while (padding-- > 0)
 		    *p++ = ' ';
 		    nchars++;
 		  }
 	      nbytes = copy_text (XSTRING (args[n])->data, p,
-				  XSTRING (args[n])->size_byte,
+				  STRING_BYTES (XSTRING (args[n])),
 				  STRING_MULTIBYTE (args[n]), multibyte);
 	      p += nbytes;
 	      nchars += XSTRING (args[n])->size;
 	      if (negative)
 {
 register int start1, end1, start2, end2;
 int start1_byte, start2_byte, len1_byte, len2_byte;
 int gap, len1, len_mid, len2;
 unsigned char *start1_addr, *start2_addr, *temp;
+int combined_before_bytes_1, combined_after_bytes_1;
+int combined_before_bytes_2, combined_after_bytes_2;
+struct gcpro gcpro1, gcpro2;
 #ifdef USE_TEXT_PROPERTIES
 INTERVAL cur_intv, tmp_interval1, tmp_interval_mid, tmp_interval2;
 cur_intv = BUF_INTERVALS (current_buffer);
 #endif /* USE_TEXT_PROPERTIES */
 len1 = end1 - start1;
 len2 = end2 - start2;
 if (start2 < end1)
-error ("Transposed regions not properly ordered");
+error ("Transposed regions overlap");
 else if (start1 == end1 || start2 == end2)
-error ("Transposed region may not be of length 0");
+error ("Transposed region has length 0");
 /* The possibilities are:
 1. Adjacent (contiguous) regions, or separate but equal regions
 (no, really equal, in this case!), or
 2. Separate regions of unequal size.
 start1_byte = CHAR_TO_BYTE (start1);
 start2_byte = CHAR_TO_BYTE (start2);
 len1_byte = CHAR_TO_BYTE (end1) - start1_byte;
 len2_byte = CHAR_TO_BYTE (end2) - start2_byte;
+if (end1 == start2)
+{
+combined_before_bytes_2
+	= count_combining_before (BYTE_POS_ADDR (start2_byte),
+				  len2_byte, start1, start1_byte);
+combined_before_bytes_1
+	= count_combining_before (BYTE_POS_ADDR (start1_byte),
+				  len1_byte, end2, start2_byte + len2_byte);
+combined_after_bytes_1
+	= count_combining_after (BYTE_POS_ADDR (start1_byte),
+				 len1_byte, end2, start2_byte + len2_byte);
+combined_after_bytes_2 = 0;
+}
+else
+{
+combined_before_bytes_2
+	= count_combining_before (BYTE_POS_ADDR (start2_byte),
+				  len2_byte, start1, start1_byte);
+combined_before_bytes_1
+	= count_combining_before (BYTE_POS_ADDR (start1_byte),
+				  len1_byte, start2, start2_byte);
+combined_after_bytes_2
+	= count_combining_after (BYTE_POS_ADDR (start2_byte),
+				 len2_byte, end1, start1_byte + len1_byte);
+combined_after_bytes_1
+	= count_combining_after (BYTE_POS_ADDR (start1_byte),
+				 len1_byte, end2, start2_byte + len2_byte);
+}
+/* If any combining is going to happen, do this the stupid way,
+because replace handles combining properly.  */
+if (combined_before_bytes_1 || combined_before_bytes_2
+|| combined_after_bytes_1 || combined_after_bytes_2)
+{
+Lisp_Object text1, text2;
+text1 = text2 = Qnil;
+GCPRO2 (text1, text2);
+text1 = make_buffer_string_both (start1, start1_byte,
+				       end1, start1_byte + len1_byte, 1);
+text2 = make_buffer_string_both (start2, start2_byte,
+				       end2, start2_byte + len2_byte, 1);
+transpose_markers (start1, end1, start2, end2,
+			 start1_byte, start1_byte + len1_byte,
+			 start2_byte, start2_byte + len2_byte);
+replace_range (text1, start2, end2, 1, 0, 1);
+replace_range (text2, start1, end1, 1, 0, 1);
+UNGCPRO;
+return Qnil;
+}
 /* Hmmm... how about checking to see if the gap is large
 enough to use as the temporary storage?  That would avoid an
 allocation... interesting.  Later, don't fool with it now.  */

Mercurial > emacs

comparison src/editfns.c @ 21245:6cde55b7c9de