From b1c6593ee525c18e9d873feb683020c001f75512 Mon Sep 17 00:00:00 2001
From: Gerd Moellmann <gerd@gnu.org>
Date: Tue, 30 Oct 2001 16:09:15 +0000
Subject: [PATCH] (to_multibyte): New function. (read1): Use it.

---
 src/ChangeLog |  3 +++
 src/lread.c   | 63 ++++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 53 insertions(+), 13 deletions(-)

diff --git a/src/ChangeLog b/src/ChangeLog
index ee2c0b84253..b9437b44c29 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,8 @@
 2001-10-30  Gerd Moellmann  <gerd@gnu.org>
 
+	* lread.c (to_multibyte): New function.
+	(read1): Use it.
+
 	* xterm.c (x_draw_relief_rect): Correct bottom relief by 1 pixel.
 	(x_set_glyph_string_background_width): Set
 	extends_to_end_of_line_p if the row's fill_line_p is set and
diff --git a/src/lread.c b/src/lread.c
index 9469ddc47ea..c94a1f291f0 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -193,6 +193,7 @@ int load_dangerous_libraries;
 
 static Lisp_Object Vbytecomp_version_regexp;
 
+static void to_multibyte P_ ((char **, char **, int *));
 static void readevalloop P_ ((Lisp_Object, FILE*, Lisp_Object, 
 			      Lisp_Object (*) (), int,
 			      Lisp_Object, Lisp_Object));
@@ -1757,6 +1758,43 @@ read_integer (readcharfun, radix)
 }
 
 
+/* Convert unibyte text in read_buffer to multibyte.
+
+   Initially, *P is a pointer after the end of the unibyte text, and
+   the pointer *END points after the end of read_buffer.
+
+   If read_buffer doesn't have enough room to hold the result
+   of the conversion, reallocate it and adjust *P and *END.
+
+   At the end, make *P point after the result of the conversion, and
+   return in *NCHARS the number of characters in the converted
+   text.  */
+
+static void
+to_multibyte (p, end, nchars)
+     char **p, **end;
+     int *nchars;
+{
+  int nbytes;
+
+  parse_str_as_multibyte (read_buffer, *p - read_buffer, &nbytes, nchars);
+  if (nbytes > read_buffer_size)
+    {
+      int offset = *p - read_buffer;
+      read_buffer_size *= 2;
+      read_buffer = (char *) xrealloc (read_buffer, read_buffer_size);
+      *p = read_buffer + offset;
+      *end = read_buffer + read_buffer_size;
+    }
+
+  if (nbytes != *nchars)
+    nbytes = str_as_multibyte (read_buffer, read_buffer_size,
+			       *p - read_buffer, nchars);
+  
+  *p = read_buffer + nbytes;
+}
+
+
 /* If the next token is ')' or ']' or '.', we store that character
    in *PCH and the return value is not interesting.  Else, we store
    zero in *PCH and we read and return one lisp object.
@@ -2110,8 +2148,8 @@ read1 (readcharfun, pch, first_in_list)
 
     case '"':
       {
-	register char *p = read_buffer;
-	register char *end = read_buffer + read_buffer_size;
+	char *p = read_buffer;
+	char *end = read_buffer + read_buffer_size;
 	register int c;
 	/* Nonzero if we saw an escape sequence specifying
 	   a multibyte character.  */
@@ -2196,15 +2234,13 @@ read1 (readcharfun, pch, first_in_list)
 	  return make_number (0);
 
 	if (force_multibyte)
-	  p = read_buffer + str_as_multibyte (read_buffer, end - read_buffer,
-					      p - read_buffer, &nchars);
+	  to_multibyte (&p, &end, &nchars);
 	else if (force_singlebyte)
 	  nchars = p - read_buffer;
 	else if (load_convert_to_unibyte)
 	  {
 	    Lisp_Object string;
-	    p = read_buffer + str_as_multibyte (read_buffer, end - read_buffer,
-						p - read_buffer, &nchars);
+	    to_multibyte (&p, &end, &nchars);
 	    if (p - read_buffer != nchars)
 	      {
 		string = make_multibyte_string (read_buffer, nchars,
@@ -2214,13 +2250,14 @@ read1 (readcharfun, pch, first_in_list)
 	  }
 	else if (EQ (readcharfun, Qget_file_char)
 		 || EQ (readcharfun, Qlambda))
-	  /* Nowadays, reading directly from a file is used only for
-	     compiled Emacs Lisp files, and those always use the
-	     Emacs internal encoding.  Meanwhile, Qlambda is used
-	     for reading dynamic byte code (compiled with
-	     byte-compile-dynamic = t).  */
-	  p = read_buffer + str_as_multibyte (read_buffer, end - read_buffer,
-					      p - read_buffer, &nchars);
+	  {
+	    /* Nowadays, reading directly from a file is used only for
+	       compiled Emacs Lisp files, and those always use the
+	       Emacs internal encoding.  Meanwhile, Qlambda is used
+	       for reading dynamic byte code (compiled with
+	       byte-compile-dynamic = t).  */
+	    to_multibyte (&p, &end, &nchars);
+	  }
 	else
 	  /* In all other cases, if we read these bytes as
 	     separate characters, treat them as separate characters now.  */
-- 
2.39.2