(to_multibyte): New function.

(read1): Use it.

diff --git a/src/ChangeLog b/src/ChangeLog
index ee2c0b84253e955c994c2e4fa922ed03854a935e..b9437b44c2909e7fd2935353651ebeb4963de8aa 100644 (file)
--- 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 9469ddc47eac9be13a60fe79148885972bc60c03..c94a1f291f02327506195cca249572f719cbe88c 100644 (file)
--- 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.  */