xemacs-beta: src/lstream.c comparison

comparison src/lstream.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	727739f917cb
children	ca9a9ec9c1c1

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 /* Written by Ben Wing. */
 #include <config.h>
 #include "lisp.h"
+#include <limits.h>
 #include "buffer.h"
 #include "insdel.h"
 #include "lstream.h"
 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_read (Lstream *stream, void *data, int size)
+int Lstream_read (Lstream *stream, void *data, size_t 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.
-int Lstream_write (Lstream *stream, void *data, int size)
+int Lstream_write (Lstream *stream, void *data, size_t 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, int size)
+void Lstream_unread (Lstream *stream, void *data, size_t 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.
 void Lstream_rewind (Lstream *stream)
 	Rewind the stream to the beginning.
 */
-#ifdef MULE
-MAC_DEFINE (Emchar, MTlstream_emchar)
-MAC_DEFINE (int, MTlstream_emcint)
-#endif
-MAC_DEFINE (struct lstream *, MTlstream_data)
-static Lisp_Object mark_lstream (Lisp_Object, void (*) (Lisp_Object));
-static void print_lstream (Lisp_Object obj, Lisp_Object printcharfun,
-			   int escapeflag);
-static void finalize_lstream (void *header, int for_disksave);
-static unsigned int sizeof_lstream (CONST void *header);
-DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("stream", lstream,
-					mark_lstream, print_lstream,
-					finalize_lstream, 0, 0,
-					sizeof_lstream, Lstream);
 #define DEFAULT_BLOCK_BUFFERING_SIZE 512
 #define MAX_READ_SIZE 512
 static Lisp_Object
 mark_lstream (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 Lstream *lstr = XLSTREAM (obj);
-if (lstr->imp->marker)
+return lstr->imp->marker ? (lstr->imp->marker) (obj, markobj) : Qnil;
-return (lstr->imp->marker) (obj, markobj);
-else
-return Qnil;
 }
 static void
 print_lstream (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 	/* Just close. */
 	Lstream_close (lstr);
 }
 }
-static unsigned int
+static size_t
 sizeof_lstream (CONST void *header)
 {
 CONST Lstream *lstr = (CONST Lstream *) header;
 return sizeof (*lstr) + lstr->imp->size - 1;
 }
+DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("stream", lstream,
+					mark_lstream, print_lstream,
+					finalize_lstream, 0, 0,
+					sizeof_lstream, Lstream);
 void
 Lstream_set_buffering (Lstream *lstr, Lstream_buffering buffering,
 		       int buffering_size)
 {
 lstr->buffering = buffering;
 void
 Lstream_delete (Lstream *lstr)
 {
 int i;
-Lisp_Object val = Qnil;
+Lisp_Object val;
 XSETLSTREAM (val, lstr);
 for (i = 0; i < lstream_type_count; i++)
 {
 if (lstream_types[i] == lstr->imp)
 }
 abort ();
 }
-static void
+#define Lstream_internal_error(reason, lstr) \
-signal_simple_internal_error (CONST char *reason, Lisp_Object obj)
+Lstream_signal_simple_error ("Internal error: " reason, lstr)
-{
+static void Lstream_signal_simple_error (CONST char *reason, Lstream *lstr)
+{
+Lisp_Object obj;
+XSETLSTREAM (obj, lstr);
 signal_simple_error (reason, obj);
 }
 void
 Lstream_reopen (Lstream *lstr)
 {
 if (lstr->flags & LSTREAM_FL_IS_OPEN)
-{
+Lstream_internal_error ("lstream already open", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream already open", obj);
-}
 lstr->flags |= LSTREAM_FL_IS_OPEN;
 }
 /* Attempt to flush out all of the buffered data for writing. */
 while (lstr->out_buffer_ind > 0)
 {
 int size = lstr->out_buffer_ind;
 if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
-	{
+	Lstream_internal_error ("lstream not open", lstr);
-	  Lisp_Object obj = Qnil;
-	  XSETLSTREAM (obj, lstr);
-	  signal_simple_internal_error
-	    ("Internal error: lstream not open", obj);
-	}
 if (! (lstr->flags & LSTREAM_FL_WRITE))
-	{
+	Lstream_internal_error ("lstream not open for writing", lstr);
-	  Lisp_Object obj = Qnil;
-	  XSETLSTREAM (obj, lstr);
-	  signal_simple_internal_error
-	    ("Internal error: lstream not open for writing", obj);
-	}
 if (!lstr->imp->writer)
-	{
+	Lstream_internal_error ("lstream has no writer", lstr);
-	  Lisp_Object obj = Qnil;
-	  XSETLSTREAM (obj, lstr);
-	  signal_simple_internal_error
-	    ("Internal error: lstream has no writer", obj);
-	}
 if (lstr->flags & LSTREAM_FL_NO_PARTIAL_CHARS)
 	/* It's quite possible for us to get passed an incomplete
 	   character at the end.  We need to spit back that
 	   incomplete character. */
 	      if (size == 0)
 		break;
 	    }
 	}
-num_written =
+num_written = (lstr->imp->writer) (lstr, lstr->out_buffer, size);
-	(lstr->imp->writer) (lstr, lstr->out_buffer, size);
 if (num_written == 0)
 	/* If nothing got written, then just hold the data.  This may
 	   occur, for example, if this stream does non-blocking I/O;
 	   the attempt to write the data might have resulted in an
 	   EWOULDBLOCK error. */
 	return 0;
-else if (num_written >= lstr->out_buffer_ind)
+else if (num_written >= (int) lstr->out_buffer_ind)
 	lstr->out_buffer_ind = 0;
 else if (num_written > 0)
 	{
 	  memmove (lstr->out_buffer, lstr->out_buffer + num_written,
 		   lstr->out_buffer_ind - num_written);
 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 int
-Lstream_adding (Lstream *lstr, int num, int force)
+Lstream_adding (Lstream *lstr, size_t num, int force)
 {
 /* Compute the size that the outbuffer needs to be after the
 chars are added. */
-int size_needed = max (lstr->out_buffer_size,
+size_t size_needed = max (lstr->out_buffer_size,
-			 num + lstr->out_buffer_ind);
+			    num + lstr->out_buffer_ind);
 /* Maybe chop it down so that we don't buffer more characters
 than our advertised buffering size. */
 if (!force)
 size_needed = min (lstr->buffering_size, size_needed);
 DO_REALLOC (lstr->out_buffer, lstr->out_buffer_size,
 }
 /* Like Lstream_write(), but does not handle line-buffering correctly. */
 static int
-Lstream_write_1 (Lstream *lstr, CONST void *data, int size)
+Lstream_write_1 (Lstream *lstr, CONST void *data, size_t size)
 {
 CONST unsigned char *p = (CONST unsigned char *) data;
 int off = 0;
 if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
-{
+Lstream_internal_error ("lstream not open", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream not open", obj);
-}
 if (! (lstr->flags & LSTREAM_FL_WRITE))
-{
+Lstream_internal_error ("lstream not open for writing", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream not open for writing", obj);
-}
 {
 int couldnt_write_last_time = 0;
 while (1)
 {
 Lstream_write_1(), which writes in chunks.  Otherwise, we
 repeatedly call Lstream_putc(), which knows how to handle
 line buffering. */
 int
-Lstream_write (Lstream *lstr, CONST void *data, int size)
+Lstream_write (Lstream *lstr, CONST void *data, size_t size)
 {
 int i;
 CONST unsigned char *p = (CONST unsigned char *) data;
-assert (size >= 0);
 if (size == 0)
 return size;
 if (lstr->buffering != LSTREAM_LINE_BUFFERED)
 return Lstream_write_1 (lstr, data, size);
-for (i = 0; i < size; i++)
+for (i = 0; i < (int) size; i++)
 {
 if (Lstream_putc (lstr, p[i]) < 0)
 	break;
 }
 return i == 0 ? -1 : 0;
 else
 return 0;
 }
 static int
-Lstream_raw_read (Lstream *lstr, unsigned char *buffer, int size)
+Lstream_raw_read (Lstream *lstr, unsigned char *buffer, size_t size)
 {
 if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
-{
+Lstream_internal_error ("lstream not open", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream not open", obj);
-}
 if (! (lstr->flags & LSTREAM_FL_READ))
-{
+Lstream_internal_error ("lstream not open for reading", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream not open for reading", obj);
-}
 if (!lstr->imp->reader)
-{
+Lstream_internal_error ("lstream has no reader", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream has no reader", obj);
-}
 return (lstr->imp->reader) (lstr, buffer, size);
 }
 /* Assuming the buffer is empty, fill it up again. */
 lstr->in_buffer_ind = 0;
 return size_gotten < 0 ? -1 : size_gotten;
 }
 int
-Lstream_read (Lstream *lstr, void *data, int size)
+Lstream_read (Lstream *lstr, void *data, size_t size)
 {
 unsigned char *p = (unsigned char *) data;
 int off = 0;
-int chunk;
+size_t chunk;
 int error_occurred = 0;
-assert (size >= 0);
 if (size == 0)
 return 0;
 /* First try to get some data from the unget buffer */
 chunk = min (size, lstr->unget_buffer_ind);
 if (chunk > 0)
 {
 /* The bytes come back in reverse order. */
-for (; off < chunk; off++)
+for (; off < (int) chunk; off++)
 	p[off] = lstr->unget_buffer[--lstr->unget_buffer_ind];
 lstr->byte_count += chunk;
 size -= chunk;
 }
 return ((off == 0 && error_occurred) ? -1 : off);
 }
 void
-Lstream_unread (Lstream *lstr, CONST void *data, int size)
+Lstream_unread (Lstream *lstr, CONST void *data, size_t size)
 {
 int i;
 unsigned char *p = (unsigned char *) data;
 /* Make sure buffer is big enough */
 int
 Lstream_rewind (Lstream *lstr)
 {
 if (!lstr->imp->rewinder)
-{
+Lstream_internal_error ("lstream has no rewinder", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream has no rewinder", obj);
-}
 if (Lstream_flush (lstr) < 0)
 return -1;
 lstr->byte_count = 0;
 return (lstr->imp->rewinder) (lstr);
 }
 Lstream_pseudo_close (Lstream *lstr)
 {
 int rc;
 if (!lstr->flags & LSTREAM_FL_IS_OPEN)
-{
+Lstream_internal_error ("lstream is not open", lstr);
-Lisp_Object obj = Qnil;
-XSETLSTREAM (obj, lstr);
-signal_simple_internal_error
-	("Internal error: lstream is not open", obj);
-}
 /* don't check errors here -- best not to risk file descriptor loss */
 rc = Lstream_flush (lstr);
 return rc;
 			       sizeof (struct stdio_stream));
 static Lisp_Object
 make_stdio_stream_1 (FILE *stream, int flags, CONST char *mode)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_stdio, mode);
 struct stdio_stream *str = STDIO_STREAM_DATA (lstr);
 str->file = stream;
 str->closing = flags & LSTR_CLOSING;
 lstr->flags |= LSTREAM_FL_CLOSE_AT_DISKSAVE;
 {
 return make_stdio_stream_1 (stream, flags, "w");
 }
 static int
-stdio_reader (Lstream *stream, unsigned char *data, int size)
+stdio_reader (Lstream *stream, unsigned char *data, size_t size)
 {
 struct stdio_stream *str = STDIO_STREAM_DATA (stream);
 size_t val = fread (data, 1, (size_t) size, str->file);
 if (!val && ferror (str->file))
 return -1;
 return (int) val;
 }
 static int
-stdio_writer (Lstream *stream, CONST unsigned char *data, int size)
+stdio_writer (Lstream *stream, CONST unsigned char *data, size_t size)
 {
 struct stdio_stream *str = STDIO_STREAM_DATA (stream);
-size_t val = fwrite (data, 1, (size_t) size, str->file);
+size_t val = fwrite (data, 1, size, str->file);
 if (!val && ferror (str->file))
 return -1;
 return (int) val;
 }
 }
 static int
 stdio_seekable_p (Lstream *stream)
 {
+struct stat lestat;
 struct stdio_stream *str = STDIO_STREAM_DATA (stream);
-{
-struct stat lestat;
+if (fstat (fileno (str->file), &lestat) < 0)
+return 0;
-if (fstat (fileno (str->file), &lestat) < 0)
+return S_ISREG (lestat.st_mode);
-return 0;
-return S_ISREG (lestat.st_mode);
-}
 }
 static int
 stdio_flusher (Lstream *stream)
 {
 ignored when writing); -1 for unlimited. */
 static Lisp_Object
 make_filedesc_stream_1 (int filedesc, int offset, int count, int flags,
 			CONST char *mode)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_filedesc, mode);
 struct filedesc_stream *fstr = FILEDESC_STREAM_DATA (lstr);
 fstr->fd = filedesc;
-fstr->closing = !!(flags & LSTR_CLOSING);
+fstr->closing      = !!(flags & LSTR_CLOSING);
-fstr->allow_quit = !!(flags & LSTR_ALLOW_QUIT);
+fstr->allow_quit   = !!(flags & LSTR_ALLOW_QUIT);
-fstr->blocked_ok = !!(flags & LSTR_BLOCKED_OK);
+fstr->blocked_ok   = !!(flags & LSTR_BLOCKED_OK);
 fstr->pty_flushing = !!(flags & LSTR_PTY_FLUSHING);
 fstr->blocking_error_p = 0;
 fstr->chars_sans_newline = 0;
 fstr->starting_pos = lseek (filedesc, offset, SEEK_CUR);
-if (fstr->starting_pos < 0)
+fstr->current_pos = max (fstr->current_pos, 0);
-fstr->current_pos = 0;
-else
-fstr->current_pos = fstr->starting_pos;
 if (count < 0)
 fstr->end_pos = -1;
 else
 fstr->end_pos = fstr->starting_pos + count;
 lstr->flags |= LSTREAM_FL_CLOSE_AT_DISKSAVE;
 {
 return make_filedesc_stream_1 (filedesc, offset, count, flags, "w");
 }
 static int
-filedesc_reader (Lstream *stream, unsigned char *data, int size)
+filedesc_reader (Lstream *stream, unsigned char *data, size_t size)
 {
+int nread;
 struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
 if (str->end_pos >= 0)
-size = min (size, str->end_pos - str->current_pos);
+size = min (size, (size_t) (str->end_pos - str->current_pos));
-size = (str->allow_quit ? read_allowing_quit : read) (str->fd, data, size);
+nread = (str->allow_quit ? read_allowing_quit : read) (str->fd, data, size);
-if (size > 0)
+if (nread > 0)
-str->current_pos += size;
+str->current_pos += nread;
-return size;
+return nread;
 }
 static int
 errno_would_block_p (int val)
 {
 #endif
 return 0;
 }
 static int
-filedesc_writer (Lstream *stream, CONST unsigned char *data, int size)
+filedesc_writer (Lstream *stream, CONST unsigned char *data, size_t size)
 {
 struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
 int retval;
 int need_newline = 0;
 Lisp_Object
 make_lisp_string_input_stream (Lisp_Object string, Bytecount offset,
 			       Bytecount len)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
 Lstream *lstr;
 struct lisp_string_stream *str;
 CHECK_STRING (string);
 if (len < 0)
 XSETLSTREAM (obj, lstr);
 return obj;
 }
 static int
-lisp_string_reader (Lstream *stream, unsigned char *data, int size)
+lisp_string_reader (Lstream *stream, unsigned char *data, size_t 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, str->end - offset);
+size = min (size, (size_t) (str->end - offset));
-assert (size >= 0); /* paranoia */
 memcpy (data, start, size);
 str->offset = offset + size;
 return size;
 }
 struct fixed_buffer_stream
 {
 CONST unsigned char *inbuf;
 unsigned char *outbuf;
-int size;
+size_t size;
-int offset;
+size_t offset;
 };
 DEFINE_LSTREAM_IMPLEMENTATION ("fixed-buffer", lstream_fixed_buffer,
 			       sizeof (struct fixed_buffer_stream));
 Lisp_Object
-make_fixed_buffer_input_stream (CONST unsigned char *buf, int size)
+make_fixed_buffer_input_stream (CONST unsigned char *buf, size_t size)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
-Lstream *lstr;
+Lstream *lstr = Lstream_new (lstream_fixed_buffer, "r");
-struct fixed_buffer_stream *str;
+struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (lstr);
-lstr = Lstream_new (lstream_fixed_buffer, "r");
-str = FIXED_BUFFER_STREAM_DATA (lstr);
 str->inbuf = buf;
 str->size = size;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
 Lisp_Object
-make_fixed_buffer_output_stream (unsigned char *buf, int size)
+make_fixed_buffer_output_stream (unsigned char *buf, size_t size)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
-Lstream *lstr;
+Lstream *lstr = Lstream_new (lstream_fixed_buffer, "w");
-struct fixed_buffer_stream *str;
+struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (lstr);
-lstr = Lstream_new (lstream_fixed_buffer, "w");
-str = FIXED_BUFFER_STREAM_DATA (lstr);
 str->outbuf = buf;
 str->size = size;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
 static int
-fixed_buffer_reader (Lstream *stream, unsigned char *data, int size)
+fixed_buffer_reader (Lstream *stream, unsigned char *data, size_t 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 int
-fixed_buffer_writer (Lstream *stream, CONST unsigned char *data, int size)
+fixed_buffer_writer (Lstream *stream, CONST unsigned char *data, size_t 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;
-int allocked;
+size_t allocked;
 int max_stored;
 int stored;
 };
 DEFINE_LSTREAM_IMPLEMENTATION ("resizing-buffer", lstream_resizing_buffer,
 			       sizeof (struct resizing_buffer_stream));
 Lisp_Object
 make_resizing_buffer_output_stream (void)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
 XSETLSTREAM (obj, Lstream_new (lstream_resizing_buffer, "w"));
 return obj;
 }
 static int
-resizing_buffer_writer (Lstream *stream, CONST unsigned char *data, int size)
+resizing_buffer_writer (Lstream *stream, CONST unsigned char *data, size_t 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;
 			       sizeof (struct dynarr_stream));
 Lisp_Object
 make_dynarr_output_stream (unsigned_char_dynarr *dyn)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
 XSETLSTREAM (obj, Lstream_new (lstream_dynarr, "w"));
 DYNARR_STREAM_DATA (XLSTREAM (obj))->dyn = dyn;
 return obj;
 }
 static int
-dynarr_writer (Lstream *stream, CONST unsigned char *data, int size)
+dynarr_writer (Lstream *stream, CONST unsigned char *data, size_t size)
 {
 struct dynarr_stream *str = DYNARR_STREAM_DATA (stream);
 Dynarr_add_many (str->dyn, data, size);
 return size;
 }
 static Lisp_Object
 make_lisp_buffer_stream_1 (struct buffer *buf, Bufpos start, Bufpos end,
 			   int flags, CONST char *mode)
 {
-Lisp_Object obj = Qnil;
+Lisp_Object obj;
 Lstream *lstr;
 struct lisp_buffer_stream *str;
 Bufpos bmin, bmax;
 int reading = !strcmp (mode, "r");
 lstr = Lstream_new (lstream_lisp_buffer, mode);
 str = LISP_BUFFER_STREAM_DATA (lstr);
 {
 Lisp_Object marker;
-Lisp_Object buffer = Qnil;
+Lisp_Object buffer;
 XSETBUFFER (buffer, buf);
 marker = Fmake_marker ();
 Fset_marker (marker, make_int (start), buffer);
 str->start = marker;
 Lstream_set_character_mode (XLSTREAM (lstr));
 return lstr;
 }
 static int
-lisp_buffer_reader (Lstream *stream, unsigned char *data, int size)
+lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t 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, end - start);
+size = min (size, (size_t) (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 int
-lisp_buffer_writer (Lstream *stream, CONST unsigned char *data, int size)
+lisp_buffer_writer (Lstream *stream, CONST unsigned char *data, size_t 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 @ 272:c5d627a313b1 r21-0b34