xemacs-beta: src/lstream.c comparison

comparison src/lstream.c @ 462:0784d089fdc9 r21-2-46

Import from CVS: tag r21-2-46

author	cvs
date	Mon, 13 Aug 2007 11:44:37 +0200
parents	e7ef97881643
children	183866b06e0b

comparison

equal deleted inserted replaced

-:120ed4009e51
+:0784d089fdc9
 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.
-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
 	there is other pending unread data.
 /* Attempt to flush out all of the buffered data for writing. */
 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))
 	Lstream_internal_error ("lstream not open for writing", lstr);
 if (!lstr->imp->writer)
 the buffering size. (This is used to deal with the possibility
 that the stream writer might refuse to write any bytes now, e.g.
 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
+static Lstream_data_count
-Lstream_adding (Lstream *lstr, size_t num, int force)
+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;
 /* Maybe chop it down so that we don't buffer more characters
 return size - lstr->out_buffer_ind;
 }
 /* Like Lstream_write(), but does not handle line-buffering correctly. */
-static ssize_t
+static Lstream_data_count
-Lstream_write_1 (Lstream *lstr, const void *data, size_t size)
+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))
 Lstream_internal_error ("lstream not open for writing", lstr);
 {
 int couldnt_write_last_time = 0;
 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)
 	      /* Ung, we ran out of space and tried to flush
 		 the buffer, but it didn't work because the stream
 /* If the stream is not line-buffered, then we can just call
 Lstream_write_1(), which writes in chunks.  Otherwise, we
 repeatedly call Lstream_putc(), which knows how to handle
 line buffering.  Returns number of bytes written. */
-ssize_t
+Lstream_data_count
-Lstream_write (Lstream *lstr, const void *data, size_t size)
+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)
 return size;
 if (lstr->buffering != LSTREAM_LINE_BUFFERED)
 for (i = 0; i < size; i++)
 {
 if (Lstream_putc (lstr, p[i]) < 0)
 	break;
 }
-return i == 0 ? -1 : (ssize_t) i;
+return i == 0 ? -1 : i;
 }
 int
 Lstream_was_blocked_p (Lstream *lstr)
 {
 return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
 }
-static ssize_t
+static Lstream_data_count
-Lstream_raw_read (Lstream *lstr, unsigned char *buffer, size_t size)
+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_READ))
 Lstream_internal_error ("lstream not open for reading", lstr);
 return (lstr->imp->reader) (lstr, buffer, 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);
 size_gotten = Lstream_raw_read (lstr, lstr->in_buffer, size_needed);
 lstr->in_buffer_current = max (0, size_gotten);
 lstr->in_buffer_ind = 0;
 return size_gotten < 0 ? -1 : size_gotten;
 }
-ssize_t
+Lstream_data_count
-Lstream_read (Lstream *lstr, void *data, size_t size)
+Lstream_read (Lstream *lstr, void *data, Lstream_data_count size)
 {
 unsigned char *p = (unsigned char *) data;
-size_t off = 0;
+Lstream_data_count off = 0;
-size_t chunk;
+Lstream_data_count chunk;
 int error_occurred = 0;
 if (size == 0)
 return 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)
 	    break;
 	}
 	     character, and bump forward to see if the character is
 	     complete. */
 	  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);
 	      off = newoff;
 	    }
 	}
 }
-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;
 /* Make sure buffer is big enough */
 DO_REALLOC (lstr->unget_buffer, lstr->unget_buffer_size,
 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;
 }
 This is probably reasonable, so I don't think we should change this
 code (it could even be argued that the error might have fixed
 itself, so we should do the fread() again.  */
-static ssize_t
+static Lstream_data_count
-stdio_reader (Lstream *stream, unsigned char *data, size_t size)
+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
+static Lstream_data_count
-stdio_writer (Lstream *stream, const unsigned char *data, size_t size)
+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;
 }
 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
+static Lstream_data_count
-filedesc_reader (Lstream *stream, unsigned char *data, size_t size)
+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);
 if (nread > 0)
 str->current_pos += nread;
 return 1;
 #endif
 return 0;
 }
-static ssize_t
+static Lstream_data_count
-filedesc_writer (Lstream *stream, const unsigned char *data, size_t size)
+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
 PTY max-bytes stuff.  Why the hell can't they just have written
 the PTY drivers right so this problem doesn't exist?
 	 and flush with an EOF if necessary.  Be careful to
 	 keep track of write errors as we go along and look
 	 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);
 	  if (retval2 > 0)
 	    str->chars_sans_newline = 0;
 first byte is a newline, we'd get stuck never writing anything
 in pty-flushing mode. */
 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);
 if (retval2 > 0)
 {
 str->obj = string;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
-static ssize_t
+static Lstream_data_count
-lisp_string_reader (Lstream *stream, unsigned char *data, size_t size)
+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 ... */
 Bytecount offset = min (str->offset, XSTRING_LENGTH (str->obj));
 Bufbyte *strstart = XSTRING_DATA (str->obj);
 /* Being in the middle of a character is `normal' unless
 LSTREAM_NO_PARTIAL_CHARS - mrb */
 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;
 }
 struct fixed_buffer_stream
 {
 const unsigned char *inbuf;
 unsigned char *outbuf;
-size_t size;
+Lstream_data_count size;
-size_t offset;
+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");
 struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (lstr);
 str->inbuf = (const unsigned char *) buf;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
 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");
 struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (lstr);
 str->outbuf = (unsigned char *) buf;
 str->size = size;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
-static ssize_t
+static Lstream_data_count
-fixed_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
+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);
 memcpy (data, str->inbuf + str->offset, size);
 str->offset += size;
 return size;
 }
-static ssize_t
+static Lstream_data_count
-fixed_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+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)
 {
 /* If we're at the end, just throw away the data and pretend
 LSTREAM_TYPE_DATA (stream, resizing_buffer)
 struct resizing_buffer_stream
 {
 unsigned char *buf;
-size_t allocked;
+Lstream_data_count allocked;
 int max_stored;
 int stored;
 };
 DEFINE_LSTREAM_IMPLEMENTATION ("resizing-buffer", lstream_resizing_buffer,
 Lisp_Object obj;
 XSETLSTREAM (obj, Lstream_new (lstream_resizing_buffer, "w"));
 return obj;
 }
-static ssize_t
+static Lstream_data_count
-resizing_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+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);
 memcpy (str->buf + str->stored, data, size);
 str->stored += size;
 XSETLSTREAM (obj, Lstream_new (lstream_dynarr, "w"));
 DYNARR_STREAM_DATA (XLSTREAM (obj))->dyn = dyn;
 return obj;
 }
-static ssize_t
+static Lstream_data_count
-dynarr_writer (Lstream *stream, const unsigned char *data, size_t size)
+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);
 return size;
 }
 Lstream_set_character_mode (XLSTREAM (lstr));
 return lstr;
 }
-static ssize_t
+static Lstream_data_count
-lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
+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;
 Bytind start;
 Bytind end;
 				     BI_BUF_ZV (buf));
 end = bytind_clip_to_bounds (BI_BUF_BEGV (buf), end,
 				   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);
 while (start < end)
 set_bi_marker_position (str->start, end);
 return data - orig_data;
 }
-static ssize_t
+static Lstream_data_count
-lisp_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+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 buffer *buf = XBUFFER (str->buffer);

Mercurial > hg > xemacs-beta

comparison src/lstream.c @ 462:0784d089fdc9 r21-2-46