(coded-charset-entity-reference-alist): Add setting for

[chise/xemacs-chise.git.1] / src / lstream.c

diff --git a/src/lstream.c b/src/lstream.c
index 29427db..8151bc7 100644 (file)
--- a/src/lstream.c
+++ b/src/lstream.c
@@ -74,37 +74,40 @@ int Lstream_putc (Lstream *stream, int c)
        0 on success, -1 on error.
 
 int Lstream_getc (Lstream *stream)
        0 on success, -1 on error.
 
 int Lstream_getc (Lstream *stream)

-       Read one byte from the stream.  This is a macro and so it
-       is very efficient.  The STREAM argument is evaluated more
-       than once.  Return value is -1 for EOF or error.
+       Read one byte from the stream and returns it as an unsigned
+       char cast to an int, or EOF on end of file or error.
+       This is a macro and so it is very efficient.  The STREAM
+       argument is evaluated more than once.

 
 void Lstream_ungetc (Lstream *stream, int c)
 
 void Lstream_ungetc (Lstream *stream, int c)

-       Push one byte back onto the input queue.  This will be the
-       next byte read from the stream.  Any number of bytes can be
-       pushed back and will be read in the reverse order they were
-       pushed back -- most recent first. (This is necessary for
-       consistency -- if there are a number of bytes that have been
-       unread and I read and unread a byte, it needs to be the first
-       to be read again.) This is a macro and so it is very
-       efficient.  The C argument is only evaluated once but the
-       STREAM argument is evaluated more than once.
+       Push one byte back onto the input queue, cast to unsigned char.
+       This will be the next byte read from the stream.  Any number
+       of bytes can be pushed back and will be read in the reverse
+       order they were pushed back -- most recent first. (This is
+       necessary for consistency -- if there are a number of bytes
+       that have been unread and I read and unread a byte, it needs
+       to be the first to be read again.) This is a macro and so it
+       is very efficient.  The C argument is only evaluated once but
+       the STREAM argument is evaluated more than once.

 
 int Lstream_fputc (Lstream *stream, int c)
 int Lstream_fgetc (Lstream *stream)
 void Lstream_fungetc (Lstream *stream, int c)
        Function equivalents of the above macros.
 
 
 int Lstream_fputc (Lstream *stream, int c)
 int Lstream_fgetc (Lstream *stream)
 void Lstream_fungetc (Lstream *stream, int c)
        Function equivalents of the above macros.
 

-ssize_t Lstream_read (Lstream *stream, void *data, size_t size)
+Lstream_data_count Lstream_read (Lstream *stream, void *data,
+                                 Lstream_data_count size)

        Read SIZE bytes of DATA from the stream.  Return the number of
        bytes read.  0 means EOF. -1 means an error occurred and no
        bytes were read.
 
        Read SIZE bytes of DATA from the stream.  Return the number of
        bytes read.  0 means EOF. -1 means an error occurred and no
        bytes were read.
 

-ssize_t Lstream_write (Lstream *stream, void *data, size_t size)
+Lstream_data_count Lstream_write (Lstream *stream, void *data,
+                                  Lstream_data_count size)

        Write SIZE bytes of DATA to the stream.  Return the number of
        bytes written.  -1 means an error occurred and no bytes were
        written.
 
        Write SIZE bytes of DATA to the stream.  Return the number of
        bytes written.  -1 means an error occurred and no bytes were
        written.
 

-void Lstream_unread (Lstream *stream, void *data, size_t size)
+void Lstream_unread (Lstream *stream, void *data, Lstream_data_count size)

        Push back SIZE bytes of DATA onto the input queue.  The
        next call to Lstream_read() with the same size will read the
        same bytes back.  Note that this will be the case even if
        Push back SIZE bytes of DATA onto the input queue.  The
        next call to Lstream_read() with the same size will read the
        same bytes back.  Note that this will be the case even if

@@ -178,11 +181,17 @@ finalize_lstream (void *header, int for_disksave)
     }
 }
 
     }
 }
 

+inline static size_t
+aligned_sizeof_lstream (size_t lstream_type_specific_size)
+{
+  return ALIGN_SIZE (offsetof (Lstream, data) + lstream_type_specific_size,
+                    ALIGNOF (max_align_t));
+}
+

 static size_t
 sizeof_lstream (const void *header)
 {
 static size_t
 sizeof_lstream (const void *header)
 {

-  const Lstream *lstr = (const Lstream *) header;
-  return sizeof (*lstr) + lstr->imp->size - 1;
+  return aligned_sizeof_lstream (((const Lstream *) header)->imp->size);

 }
 
 DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("stream", lstream,
 }
 
 DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("stream", lstream,

@@ -230,15 +239,15 @@ Lstream_new (const Lstream_implementation *imp, const char *mode)
       assert (lstream_type_count < countof (lstream_types));
       lstream_types[lstream_type_count] = imp;
       Vlstream_free_list[lstream_type_count] =
       assert (lstream_type_count < countof (lstream_types));
       lstream_types[lstream_type_count] = imp;
       Vlstream_free_list[lstream_type_count] =

-       make_lcrecord_list (sizeof (*p) + imp->size - 1,
+       make_lcrecord_list (aligned_sizeof_lstream (imp->size),

                            &lrecord_lstream);
       lstream_type_count++;
     }
 
   p = XLSTREAM (allocate_managed_lcrecord (Vlstream_free_list[i]));
   /* Zero it out, except the header. */
                            &lrecord_lstream);
       lstream_type_count++;
     }
 
   p = XLSTREAM (allocate_managed_lcrecord (Vlstream_free_list[i]));
   /* Zero it out, except the header. */

-  memset ((char *) p + sizeof (p->header), 0,
-         sizeof (*p) - sizeof (p->header) + imp->size - 1);
+  memset ((char *) p + sizeof (p->header), '\0',
+         aligned_sizeof_lstream (imp->size) - sizeof (p->header));

   p->imp = imp;
   Lstream_set_buffering (p, LSTREAM_BLOCK_BUFFERED, 0);
   p->flags = LSTREAM_FL_IS_OPEN;
   p->imp = imp;
   Lstream_set_buffering (p, LSTREAM_BLOCK_BUFFERED, 0);
   p->flags = LSTREAM_FL_IS_OPEN;

@@ -275,7 +284,7 @@ Lstream_delete (Lstream *lstr)
        }
     }
 
        }
     }
 

-  abort ();
+  ABORT ();

 }
 
 #define Lstream_internal_error(reason, lstr) \
 }
 
 #define Lstream_internal_error(reason, lstr) \

@@ -301,11 +310,11 @@ Lstream_reopen (Lstream *lstr)
 int
 Lstream_flush_out (Lstream *lstr)
 {
 int
 Lstream_flush_out (Lstream *lstr)
 {

-  ssize_t num_written;
+  Lstream_data_count num_written;

 
   while (lstr->out_buffer_ind > 0)
     {
 
   while (lstr->out_buffer_ind > 0)
     {

-      size_t size = lstr->out_buffer_ind;
+      Lstream_data_count size = lstr->out_buffer_ind;

       if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
        Lstream_internal_error ("lstream not open", lstr);
       if (! (lstr->flags & LSTREAM_FL_WRITE))
       if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
        Lstream_internal_error ("lstream not open", lstr);
       if (! (lstr->flags & LSTREAM_FL_WRITE))

@@ -388,10 +397,10 @@ Lstream_flush (Lstream *lstr)
    if it's getting EWOULDBLOCK errors.   We have to keep stocking them
    up until they can be written, so as to avoid losing data. */
 
    if it's getting EWOULDBLOCK errors.   We have to keep stocking them
    up until they can be written, so as to avoid losing data. */
 

-static size_t
-Lstream_adding (Lstream *lstr, size_t num, int force)
+static Lstream_data_count
+Lstream_adding (Lstream *lstr, Lstream_data_count num, int force)

 {
 {

-  size_t size = num + lstr->out_buffer_ind;
+  Lstream_data_count size = num + lstr->out_buffer_ind;

 
   if (size <= lstr->out_buffer_size)
     return num;
 
   if (size <= lstr->out_buffer_size)
     return num;

@@ -413,11 +422,11 @@ Lstream_adding (Lstream *lstr, size_t num, int force)
 
 /* Like Lstream_write(), but does not handle line-buffering correctly. */
 
 
 /* Like Lstream_write(), but does not handle line-buffering correctly. */
 

-static ssize_t
-Lstream_write_1 (Lstream *lstr, const void *data, size_t size)
+static Lstream_data_count
+Lstream_write_1 (Lstream *lstr, const void *data, Lstream_data_count size)

 {
   const unsigned char *p = (const unsigned char *) data;
 {
   const unsigned char *p = (const unsigned char *) data;

-  ssize_t off = 0;
+  Lstream_data_count off = 0;

   if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
     Lstream_internal_error ("lstream not open", lstr);
   if (! (lstr->flags & LSTREAM_FL_WRITE))
   if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
     Lstream_internal_error ("lstream not open", lstr);
   if (! (lstr->flags & LSTREAM_FL_WRITE))

@@ -428,7 +437,7 @@ Lstream_write_1 (Lstream *lstr, const void *data, size_t size)
     while (1)
       {
        /* Figure out how much we can add to the buffer */
     while (1)
       {
        /* Figure out how much we can add to the buffer */

-       size_t chunk = Lstream_adding (lstr, size, 0);
+       Lstream_data_count chunk = Lstream_adding (lstr, size, 0);

        if (chunk == 0)
          {
            if (couldnt_write_last_time)
        if (chunk == 0)
          {
            if (couldnt_write_last_time)

@@ -473,10 +482,10 @@ Lstream_write_1 (Lstream *lstr, const void *data, size_t size)
    repeatedly call Lstream_putc(), which knows how to handle
    line buffering.  Returns number of bytes written. */
 
    repeatedly call Lstream_putc(), which knows how to handle
    line buffering.  Returns number of bytes written. */
 

-ssize_t
-Lstream_write (Lstream *lstr, const void *data, size_t size)
+Lstream_data_count
+Lstream_write (Lstream *lstr, const void *data, Lstream_data_count size)

 {
 {

-  size_t i;
+  Lstream_data_count i;

   const unsigned char *p = (const unsigned char *) data;
 
   if (size == 0)
   const unsigned char *p = (const unsigned char *) data;
 
   if (size == 0)

@@ -488,7 +497,7 @@ Lstream_write (Lstream *lstr, const void *data, size_t size)
       if (Lstream_putc (lstr, p[i]) < 0)
        break;
     }
       if (Lstream_putc (lstr, p[i]) < 0)
        break;
     }

-  return i == 0 ? -1 : (ssize_t) i;
+  return i == 0 ? -1 : i;

 }
 
 int
 }
 
 int

@@ -497,8 +506,9 @@ Lstream_was_blocked_p (Lstream *lstr)
   return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
 }
 
   return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
 }
 

-static int
-Lstream_raw_read (Lstream *lstr, unsigned char *buffer, size_t size)
+static Lstream_data_count
+Lstream_raw_read (Lstream *lstr, unsigned char *buffer,
+                 Lstream_data_count size)

 {
   if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
     Lstream_internal_error ("lstream not open", lstr);
 {
   if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
     Lstream_internal_error ("lstream not open", lstr);

@@ -512,16 +522,18 @@ Lstream_raw_read (Lstream *lstr, unsigned char *buffer, size_t size)
 
 /* Assuming the buffer is empty, fill it up again. */
 
 
 /* Assuming the buffer is empty, fill it up again. */
 

-static ssize_t
+static Lstream_data_count

 Lstream_read_more (Lstream *lstr)
 {
 #if 0
 Lstream_read_more (Lstream *lstr)
 {
 #if 0

-  ssize_t size_needed = max (1, min (MAX_READ_SIZE, lstr->buffering_size));
+  Lstream_data_count size_needed 
+    = max (1, min (MAX_READ_SIZE, lstr->buffering_size));

 #else
   /* If someone requested a larger buffer size, so be it! */
 #else
   /* If someone requested a larger buffer size, so be it! */

-  ssize_t size_needed = max (1, lstr->buffering_size);
+  Lstream_data_count size_needed =
+    max (1, lstr->buffering_size);

 #endif
 #endif

-  ssize_t size_gotten;
+  Lstream_data_count size_gotten;

 
   DO_REALLOC (lstr->in_buffer, lstr->in_buffer_size,
              size_needed, unsigned char);
 
   DO_REALLOC (lstr->in_buffer, lstr->in_buffer_size,
              size_needed, unsigned char);

@@ -531,12 +543,12 @@ Lstream_read_more (Lstream *lstr)
   return size_gotten < 0 ? -1 : size_gotten;
 }
 
   return size_gotten < 0 ? -1 : size_gotten;
 }
 

-ssize_t
-Lstream_read (Lstream *lstr, void *data, size_t size)
+Lstream_data_count
+Lstream_read (Lstream *lstr, void *data, Lstream_data_count size)

 {
   unsigned char *p = (unsigned char *) data;
 {
   unsigned char *p = (unsigned char *) data;

-  size_t off = 0;
-  size_t chunk;
+  Lstream_data_count off = 0;
+  Lstream_data_count chunk;

   int error_occurred = 0;
 
   if (size == 0)
   int error_occurred = 0;
 
   if (size == 0)

@@ -569,7 +581,7 @@ Lstream_read (Lstream *lstr, void *data, size_t size)
       /* If we need some more, try to get some more from the stream's end */
       if (size > 0)
        {
       /* If we need some more, try to get some more from the stream's end */
       if (size > 0)
        {

-         ssize_t retval = Lstream_read_more (lstr);
+         Lstream_data_count retval = Lstream_read_more (lstr);

          if (retval < 0)
            error_occurred = 1;
          if (retval <= 0)
          if (retval < 0)
            error_occurred = 1;
          if (retval <= 0)

@@ -593,7 +605,7 @@ Lstream_read (Lstream *lstr, void *data, size_t size)
          VALIDATE_CHARPTR_BACKWARD (dataend);
          if (dataend + REP_BYTES_BY_FIRST_BYTE (*dataend) != p + off)
            {
          VALIDATE_CHARPTR_BACKWARD (dataend);
          if (dataend + REP_BYTES_BY_FIRST_BYTE (*dataend) != p + off)
            {

-             size_t newoff = dataend - p;
+             Lstream_data_count newoff = dataend - p;

              /* If not, chop the size down to ignore the last char
                 and stash it away for next time. */
              Lstream_unread (lstr, dataend, off - newoff);
              /* If not, chop the size down to ignore the last char
                 and stash it away for next time. */
              Lstream_unread (lstr, dataend, off - newoff);

@@ -602,11 +614,11 @@ Lstream_read (Lstream *lstr, void *data, size_t size)
        }
     }
 
        }
     }
 

-  return off == 0 && error_occurred ? -1 : (ssize_t) off;
+  return off == 0 && error_occurred ? -1 : off;

 }
 
 void
 }
 
 void

-Lstream_unread (Lstream *lstr, const void *data, size_t size)
+Lstream_unread (Lstream *lstr, const void *data, Lstream_data_count size)

 {
   const unsigned char *p = (const unsigned char *) data;
 
 {
   const unsigned char *p = (const unsigned char *) data;
 

@@ -646,7 +658,7 @@ Lstream_seekable_p (Lstream *lstr)
 static int
 Lstream_pseudo_close (Lstream *lstr)
 {
 static int
 Lstream_pseudo_close (Lstream *lstr)
 {

-  if (!lstr->flags & LSTREAM_FL_IS_OPEN)
+  if (! (lstr->flags & LSTREAM_FL_IS_OPEN))

     Lstream_internal_error ("lstream is not open", lstr);
 
   /* don't check errors here -- best not to risk file descriptor loss */
     Lstream_internal_error ("lstream is not open", lstr);
 
   /* don't check errors here -- best not to risk file descriptor loss */

@@ -725,7 +737,7 @@ int
 Lstream_fputc (Lstream *lstr, int c)
 {
   unsigned char ch = (unsigned char) c;
 Lstream_fputc (Lstream *lstr, int c)
 {
   unsigned char ch = (unsigned char) c;

-  ssize_t retval = Lstream_write_1 (lstr, &ch, 1);
+  Lstream_data_count retval = Lstream_write_1 (lstr, &ch, 1);

   if (retval >= 0 && lstr->buffering == LSTREAM_LINE_BUFFERED && ch == '\n')
     return Lstream_flush_out (lstr);
   return retval < 0 ? -1 : 0;
   if (retval >= 0 && lstr->buffering == LSTREAM_LINE_BUFFERED && ch == '\n')
     return Lstream_flush_out (lstr);
   return retval < 0 ? -1 : 0;

@@ -806,21 +818,22 @@ make_stdio_output_stream (FILE *stream, int flags)
    code (it could even be argued that the error might have fixed
    itself, so we should do the fread() again.  */
 
    code (it could even be argued that the error might have fixed
    itself, so we should do the fread() again.  */
 

-static ssize_t
-stdio_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+stdio_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)

 {
   struct stdio_stream *str = STDIO_STREAM_DATA (stream);
 {
   struct stdio_stream *str = STDIO_STREAM_DATA (stream);

-  size_t val = fread (data, 1, size, str->file);
+  Lstream_data_count val = fread (data, 1, size, str->file);

   if (!val && ferror (str->file))
     return -1;
   return val;
 }
 
   if (!val && ferror (str->file))
     return -1;
   return val;
 }
 

-static ssize_t
-stdio_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+stdio_writer (Lstream *stream, const unsigned char *data,
+             Lstream_data_count size)

 {
   struct stdio_stream *str = STDIO_STREAM_DATA (stream);
 {
   struct stdio_stream *str = STDIO_STREAM_DATA (stream);

-  size_t val = fwrite (data, 1, size, str->file);
+  Lstream_data_count val = fwrite (data, 1, size, str->file);

   if (!val && ferror (str->file))
     return -1;
   return val;
   if (!val && ferror (str->file))
     return -1;
   return val;

@@ -931,13 +944,13 @@ make_filedesc_output_stream (int filedesc, int offset, int count, int flags)
   return make_filedesc_stream_1 (filedesc, offset, count, flags, "w");
 }
 
   return make_filedesc_stream_1 (filedesc, offset, count, flags, "w");
 }
 

-static ssize_t
-filedesc_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+filedesc_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)

 {
 {

-  ssize_t nread;
+  Lstream_data_count nread;

   struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
   if (str->end_pos >= 0)
   struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
   if (str->end_pos >= 0)

-    size = min (size, (size_t) (str->end_pos - str->current_pos));
+    size = min (size, (Lstream_data_count) (str->end_pos - str->current_pos));

   nread = str->allow_quit ?
     read_allowing_quit (str->fd, data, size) :
     read (str->fd, data, size);
   nread = str->allow_quit ?
     read_allowing_quit (str->fd, data, size) :
     read (str->fd, data, size);

@@ -960,11 +973,12 @@ errno_would_block_p (int val)
   return 0;
 }
 
   return 0;
 }
 

-static ssize_t
-filedesc_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+filedesc_writer (Lstream *stream, const unsigned char *data,
+                Lstream_data_count size)

 {
   struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
 {
   struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);

-  ssize_t retval;
+  Lstream_data_count retval;

   int need_newline = 0;
 
   /* This function would be simple if it were not for the blasted
   int need_newline = 0;
 
   /* This function would be simple if it were not for the blasted

@@ -1018,7 +1032,7 @@ filedesc_writer (Lstream *stream, const unsigned char *data, size_t size)
         out for EWOULDBLOCK. */
       if (str->chars_sans_newline >= str->pty_max_bytes)
        {
         out for EWOULDBLOCK. */
       if (str->chars_sans_newline >= str->pty_max_bytes)
        {

-         ssize_t retval2 = str->allow_quit ?
+         Lstream_data_count retval2 = str->allow_quit ?

            write_allowing_quit (str->fd, &str->eof_char, 1) :
            write (str->fd, &str->eof_char, 1);
 
            write_allowing_quit (str->fd, &str->eof_char, 1) :
            write (str->fd, &str->eof_char, 1);
 

@@ -1051,7 +1065,7 @@ filedesc_writer (Lstream *stream, const unsigned char *data, size_t size)
   if (need_newline)
     {
       Bufbyte nl = '\n';
   if (need_newline)
     {
       Bufbyte nl = '\n';

-      ssize_t retval2 = str->allow_quit ?
+      Lstream_data_count retval2 = str->allow_quit ?

        write_allowing_quit (str->fd, &nl, 1) :
        write (str->fd, &nl, 1);
 
        write_allowing_quit (str->fd, &nl, 1) :
        write (str->fd, &nl, 1);
 

@@ -1187,8 +1201,9 @@ make_lisp_string_input_stream (Lisp_Object string, Bytecount offset,
   return obj;
 }
 
   return obj;
 }
 

-static ssize_t
-lisp_string_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+lisp_string_reader (Lstream *stream, unsigned char *data,
+                   Lstream_data_count size)

 {
   struct lisp_string_stream *str = LISP_STRING_STREAM_DATA (stream);
   /* Don't lose if the string shrank past us ... */
 {
   struct lisp_string_stream *str = LISP_STRING_STREAM_DATA (stream);
   /* Don't lose if the string shrank past us ... */

@@ -1203,7 +1218,7 @@ lisp_string_reader (Lstream *stream, unsigned char *data, size_t size)
   if (stream->flags & LSTREAM_FL_NO_PARTIAL_CHARS)
     VALIDATE_CHARPTR_BACKWARD (start);
   offset = start - strstart;
   if (stream->flags & LSTREAM_FL_NO_PARTIAL_CHARS)
     VALIDATE_CHARPTR_BACKWARD (start);
   offset = start - strstart;

-  size = min (size, (size_t) (str->end - offset));
+  size = min (size, (Lstream_data_count) (str->end - offset));

   memcpy (data, start, size);
   str->offset = offset + size;
   return size;
   memcpy (data, start, size);
   str->offset = offset + size;
   return size;

@@ -1246,15 +1261,15 @@ struct fixed_buffer_stream
 {
   const unsigned char *inbuf;
   unsigned char *outbuf;
 {
   const unsigned char *inbuf;
   unsigned char *outbuf;

-  size_t size;
-  size_t offset;
+  Lstream_data_count size;
+  Lstream_data_count offset;

 };
 
 DEFINE_LSTREAM_IMPLEMENTATION ("fixed-buffer", lstream_fixed_buffer,
                               sizeof (struct fixed_buffer_stream));
 
 Lisp_Object
 };
 
 DEFINE_LSTREAM_IMPLEMENTATION ("fixed-buffer", lstream_fixed_buffer,
                               sizeof (struct fixed_buffer_stream));
 
 Lisp_Object

-make_fixed_buffer_input_stream (const void *buf, size_t size)
+make_fixed_buffer_input_stream (const void *buf, Lstream_data_count size)

 {
   Lisp_Object obj;
   Lstream *lstr = Lstream_new (lstream_fixed_buffer, "r");
 {
   Lisp_Object obj;
   Lstream *lstr = Lstream_new (lstream_fixed_buffer, "r");

@@ -1266,7 +1281,7 @@ make_fixed_buffer_input_stream (const void *buf, size_t size)
 }
 
 Lisp_Object
 }
 
 Lisp_Object

-make_fixed_buffer_output_stream (void *buf, size_t size)
+make_fixed_buffer_output_stream (void *buf, Lstream_data_count size)

 {
   Lisp_Object obj;
   Lstream *lstr = Lstream_new (lstream_fixed_buffer, "w");
 {
   Lisp_Object obj;
   Lstream *lstr = Lstream_new (lstream_fixed_buffer, "w");

@@ -1277,8 +1292,9 @@ make_fixed_buffer_output_stream (void *buf, size_t size)
   return obj;
 }
 
   return obj;
 }
 

-static ssize_t
-fixed_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+fixed_buffer_reader (Lstream *stream, unsigned char *data,
+                    Lstream_data_count size)

 {
   struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream);
   size = min (size, str->size - str->offset);
 {
   struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream);
   size = min (size, str->size - str->offset);

@@ -1287,8 +1303,9 @@ fixed_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
   return size;
 }
 
   return size;
 }
 

-static ssize_t
-fixed_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+fixed_buffer_writer (Lstream *stream, const unsigned char *data,
+                    Lstream_data_count size)

 {
   struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream);
   if (str->offset == str->size)
 {
   struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream);
   if (str->offset == str->size)

@@ -1333,7 +1350,7 @@ fixed_buffer_output_stream_ptr (Lstream *stream)
 struct resizing_buffer_stream
 {
   unsigned char *buf;
 struct resizing_buffer_stream
 {
   unsigned char *buf;

-  size_t allocked;
+  Lstream_data_count allocked;

   int max_stored;
   int stored;
 };
   int max_stored;
   int stored;
 };

@@ -1349,8 +1366,9 @@ make_resizing_buffer_output_stream (void)
   return obj;
 }
 
   return obj;
 }
 

-static ssize_t
-resizing_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+resizing_buffer_writer (Lstream *stream, const unsigned char *data,
+                       Lstream_data_count size)

 {
   struct resizing_buffer_stream *str = RESIZING_BUFFER_STREAM_DATA (stream);
   DO_REALLOC (str->buf, str->allocked, str->stored + size, unsigned char);
 {
   struct resizing_buffer_stream *str = RESIZING_BUFFER_STREAM_DATA (stream);
   DO_REALLOC (str->buf, str->allocked, str->stored + size, unsigned char);

@@ -1411,8 +1429,9 @@ make_dynarr_output_stream (unsigned_char_dynarr *dyn)
   return obj;
 }
 
   return obj;
 }
 

-static ssize_t
-dynarr_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+dynarr_writer (Lstream *stream, const unsigned char *data,
+              Lstream_data_count size)

 {
   struct dynarr_stream *str = DYNARR_STREAM_DATA (stream);
   Dynarr_add_many (str->dyn, data, size);
 {
   struct dynarr_stream *str = DYNARR_STREAM_DATA (stream);
   Dynarr_add_many (str->dyn, data, size);

@@ -1465,7 +1484,7 @@ make_lisp_buffer_stream_1 (struct buffer *buf, Bufpos start, Bufpos end,
 
   /* Make sure the luser didn't pass "w" in. */
   if (!strcmp (mode, "w"))
 
   /* Make sure the luser didn't pass "w" in. */
   if (!strcmp (mode, "w"))

-    abort ();
+    ABORT ();

 
   if (flags & LSTR_IGNORE_ACCESSIBLE)
     {
 
   if (flags & LSTR_IGNORE_ACCESSIBLE)
     {

@@ -1535,8 +1554,9 @@ make_lisp_buffer_output_stream (struct buffer *buf, Bufpos pos, int flags)
   return lstr;
 }
 
   return lstr;
 }
 

-static ssize_t
-lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+lisp_buffer_reader (Lstream *stream, unsigned char *data,
+                   Lstream_data_count size)

 {
   struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
   unsigned char *orig_data = data;
 {
   struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
   unsigned char *orig_data = data;

@@ -1560,7 +1580,7 @@ lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
                                   BI_BUF_ZV (buf));
     }
 
                                   BI_BUF_ZV (buf));
     }
 

-  size = min (size, (size_t) (end - start));
+  size = min (size, (Lstream_data_count) (end - start));

   end = start + size;
   /* We cannot return a partial character. */
   VALIDATE_BYTIND_BACKWARD (buf, end);
   end = start + size;
   /* We cannot return a partial character. */
   VALIDATE_BYTIND_BACKWARD (buf, end);

@@ -1593,8 +1613,9 @@ lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
   return data - orig_data;
 }
 
   return data - orig_data;
 }
 

-static ssize_t
-lisp_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+lisp_buffer_writer (Lstream *stream, const unsigned char *data,
+                   Lstream_data_count size)

 {
   struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
   Bufpos pos;
 {
   struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
   Bufpos pos;