X-Git-Url: http://git.chise.org/gitweb/?p=chise%2Fxemacs-chise.git.1;a=blobdiff_plain;f=src%2Flstream.c;h=8151bc7cc0268e30477aa27ba857bfc7eef49e3f;hp=d413800af0996d1cc672a415e10c0deb12eff7e7;hb=14ac73276fa152e8f0b74602792afc0b9c3236c9;hpb=3198ed8319f99e19a14447745f4f93e4b4522961

diff --git a/src/lstream.c b/src/lstream.c
index d413800..8151bc7 100644
--- a/src/lstream.c
+++ b/src/lstream.c
@@ -95,17 +95,19 @@ 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.
 
-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.
 
-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
@@ -282,7 +284,7 @@ Lstream_delete (Lstream *lstr)
 	}
     }
 
-  abort ();
+  ABORT ();
 }
 
 #define Lstream_internal_error(reason, lstr) \
@@ -308,11 +310,11 @@ Lstream_reopen (Lstream *lstr)
 int
 Lstream_flush_out (Lstream *lstr)
 {
-  ssize_t num_written;
+  Lstream_data_count num_written;
 
   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))
@@ -395,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. */
 
-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;
@@ -420,11 +422,11 @@ Lstream_adding (Lstream *lstr, size_t num, int force)
 
 /* 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;
-  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))
@@ -435,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 */
-	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)
@@ -480,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. */
 
-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)
@@ -495,7 +497,7 @@ Lstream_write (Lstream *lstr, const void *data, size_t size)
       if (Lstream_putc (lstr, p[i]) < 0)
 	break;
     }
-  return i == 0 ? -1 : (ssize_t) i;
+  return i == 0 ? -1 : i;
 }
 
 int
@@ -504,8 +506,9 @@ Lstream_was_blocked_p (Lstream *lstr)
   return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
 }
 
-static ssize_t
-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);
@@ -519,16 +522,18 @@ Lstream_raw_read (Lstream *lstr, unsigned char *buffer, size_t size)
 
 /* Assuming the buffer is empty, fill it up again. */
 
-static ssize_t
+static Lstream_data_count
 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! */
-  ssize_t size_needed = max (1, lstr->buffering_size);
+  Lstream_data_count size_needed =
+    max (1, lstr->buffering_size);
 #endif
-  ssize_t size_gotten;
+  Lstream_data_count size_gotten;
 
   DO_REALLOC (lstr->in_buffer, lstr->in_buffer_size,
 	      size_needed, unsigned char);
@@ -538,12 +543,12 @@ Lstream_read_more (Lstream *lstr)
   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;
-  size_t off = 0;
-  size_t chunk;
+  Lstream_data_count off = 0;
+  Lstream_data_count chunk;
   int error_occurred = 0;
 
   if (size == 0)
@@ -576,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)
 	{
-	  ssize_t retval = Lstream_read_more (lstr);
+	  Lstream_data_count retval = Lstream_read_more (lstr);
 	  if (retval < 0)
 	    error_occurred = 1;
 	  if (retval <= 0)
@@ -600,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)
 	    {
-	      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);
@@ -609,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
-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;
 
@@ -653,7 +658,7 @@ Lstream_seekable_p (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 */
@@ -732,7 +737,7 @@ int
 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;
@@ -813,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.  */
 
-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);
-  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;
 }
 
-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);
-  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;
@@ -938,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");
 }
 
-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)
-    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);
@@ -967,11 +973,12 @@ errno_would_block_p (int val)
   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);
-  ssize_t retval;
+  Lstream_data_count retval;
   int need_newline = 0;
 
   /* This function would be simple if it were not for the blasted
@@ -1025,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)
 	{
-	  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);
 
@@ -1058,7 +1065,7 @@ filedesc_writer (Lstream *stream, const unsigned char *data, size_t size)
   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);
 
@@ -1194,8 +1201,9 @@ make_lisp_string_input_stream (Lisp_Object string, Bytecount offset,
   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 ... */
@@ -1210,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;
-  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;
@@ -1253,15 +1261,15 @@ struct fixed_buffer_stream
 {
   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
-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");
@@ -1273,7 +1281,7 @@ make_fixed_buffer_input_stream (const void *buf, size_t size)
 }
 
 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");
@@ -1284,8 +1292,9 @@ make_fixed_buffer_output_stream (void *buf, size_t size)
   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);
@@ -1294,8 +1303,9 @@ fixed_buffer_reader (Lstream *stream, unsigned char *data, size_t 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)
@@ -1340,7 +1350,7 @@ fixed_buffer_output_stream_ptr (Lstream *stream)
 struct resizing_buffer_stream
 {
   unsigned char *buf;
-  size_t allocked;
+  Lstream_data_count allocked;
   int max_stored;
   int stored;
 };
@@ -1356,8 +1366,9 @@ make_resizing_buffer_output_stream (void)
   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);
@@ -1418,8 +1429,9 @@ make_dynarr_output_stream (unsigned_char_dynarr *dyn)
   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);
@@ -1472,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"))
-    abort ();
+    ABORT ();
 
   if (flags & LSTR_IGNORE_ACCESSIBLE)
     {
@@ -1542,8 +1554,9 @@ make_lisp_buffer_output_stream (struct buffer *buf, Bufpos pos, int flags)
   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;
@@ -1567,7 +1580,7 @@ lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
 				   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);
@@ -1600,8 +1613,9 @@ lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
   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;