xemacs-beta: src/lstream.c comparison

comparison src/lstream.c @ 398:74fd4e045ea6 r21-2-29

Import from CVS: tag r21-2-29

author	cvs
date	Mon, 13 Aug 2007 11:13:30 +0200
parents	8626e4521993
children	a86b2b5e0111

comparison

equal deleted inserted replaced

-:f4aeb21a5bad
+:74fd4e045ea6
 in C.  The reason for this is that "stream" is too generic a name
 for C; too much likelihood of conflict/confusion with C++, etc. */
 /* Functions are as follows:
-Lstream *Lstream_new (Lstream_implementation *imp, CONST char *mode)
+Lstream *Lstream_new (Lstream_implementation *imp, const char *mode)
 	Allocate and return a new Lstream.  This function is not
 	really meant to be called directly; rather, each stream type
 	should provide its own stream creation function, which
 	creates the stream and does any other necessary creation
 	stuff (e.g. opening a file).
 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, size_t size)
+ssize_t 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, size_t size)
+ssize_t 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, size_t size)
 #define DEFAULT_BLOCK_BUFFERING_SIZE 512
 #define MAX_READ_SIZE 512
 static Lisp_Object
-mark_lstream (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_lstream (Lisp_Object obj)
 {
 Lstream *lstr = XLSTREAM (obj);
-return lstr->imp->marker ? (lstr->imp->marker) (obj, markobj) : Qnil;
+return lstr->imp->marker ? (lstr->imp->marker) (obj) : Qnil;
 }
 static void
 print_lstream (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 	Lstream_close (lstr);
 }
 }
 static size_t
-sizeof_lstream (CONST void *header)
+sizeof_lstream (const void *header)
 {
-CONST Lstream *lstr = (CONST Lstream *) 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,
+					finalize_lstream, 0, 0, 0,
 					sizeof_lstream, Lstream);
 void
 Lstream_set_buffering (Lstream *lstr, Lstream_buffering buffering,
 		       int buffering_size)
 case LSTREAM_UNLIMITED:
 lstr->buffering_size = INT_MAX; break;
 }
 }
-static CONST Lstream_implementation *lstream_types[32];
+static const Lstream_implementation *lstream_types[32];
 static Lisp_Object Vlstream_free_list[32];
 static int lstream_type_count;
 Lstream *
-Lstream_new (CONST Lstream_implementation *imp, CONST char *mode)
+Lstream_new (const Lstream_implementation *imp, const char *mode)
 {
 Lstream *p;
 int i;
 for (i = 0; i < lstream_type_count; i++)
 {
 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,
-			    lrecord_lstream);
+			    &lrecord_lstream);
 lstream_type_count++;
 }
 p = XLSTREAM (allocate_managed_lcrecord (Vlstream_free_list[i]));
 /* Zero it out, except the header. */
 }
 #define Lstream_internal_error(reason, lstr) \
 Lstream_signal_simple_error ("Internal error: " reason, lstr)
-static void Lstream_signal_simple_error (CONST char *reason, Lstream *lstr)
+static void Lstream_signal_simple_error (const char *reason, Lstream *lstr)
 {
 Lisp_Object obj;
 XSETLSTREAM (obj, lstr);
 signal_simple_error (reason, obj);
 }
 /* Attempt to flush out all of the buffered data for writing. */
 int
 Lstream_flush_out (Lstream *lstr)
 {
-int num_written;
+ssize_t num_written;
 while (lstr->out_buffer_ind > 0)
 {
-int size = lstr->out_buffer_ind;
+size_t 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)
 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. */
 	{
-	  CONST unsigned char *data = lstr->out_buffer;
+	  const unsigned char *data = lstr->out_buffer;
-	  CONST unsigned char *dataend = data + size - 1;
+	  const unsigned char *dataend = data + size - 1;
 	  assert (size > 0); /* safety check ... */
 	  /* Optimize the most common case. */
 	  if (!BYTE_ASCII_P (*dataend))
 	    {
 	      /* Go back to the beginning of the last (and possibly partial)
 	/* 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 >= (int) lstr->out_buffer_ind)
+else if (num_written >= 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);
 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 int
+static size_t
 Lstream_adding (Lstream *lstr, size_t num, int force)
 {
-/* Compute the size that the outbuffer needs to be after the
+size_t size = num + lstr->out_buffer_ind;
-chars are added. */
-size_t size_needed = max (lstr->out_buffer_size,
+if (size <= lstr->out_buffer_size)
-			    num + lstr->out_buffer_ind);
+return num;
 /* Maybe chop it down so that we don't buffer more characters
 than our advertised buffering size. */
-if (!force)
+if ((size > lstr->buffering_size) && !force)
-size_needed = min (lstr->buffering_size, size_needed);
+{
-DO_REALLOC (lstr->out_buffer, lstr->out_buffer_size,
+size = lstr->buffering_size;
-	      size_needed, unsigned char);
+/* There might be more data buffered than the buffering size. */
-/* There might be more data buffered than the buffering size,
+if (size <= lstr->out_buffer_ind)
-so make sure we don't return a negative number here. */
+	return 0;
-return max (0, min (num, size_needed - lstr->out_buffer_ind));
+}
+DO_REALLOC (lstr->out_buffer, lstr->out_buffer_size, size, unsigned char);
+return size - lstr->out_buffer_ind;
 }
 /* Like Lstream_write(), but does not handle line-buffering correctly. */
-static int
+static ssize_t
-Lstream_write_1 (Lstream *lstr, CONST void *data, size_t size)
+Lstream_write_1 (Lstream *lstr, const void *data, size_t size)
 {
-CONST unsigned char *p = (CONST unsigned char *) data;
+const unsigned char *p = (const unsigned char *) data;
-int off = 0;
+ssize_t 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 */
-	int chunk = Lstream_adding (lstr, size, 0);
+	size_t 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. */
+line buffering.  Returns number of bytes written. */
-int
+ssize_t
-Lstream_write (Lstream *lstr, CONST void *data, size_t size)
+Lstream_write (Lstream *lstr, const void *data, size_t size)
 {
-int i;
+size_t i;
-CONST unsigned char *p = (CONST unsigned char *) data;
+const unsigned char *p = (const unsigned char *) data;
 if (size == 0)
 return size;
 if (lstr->buffering != LSTREAM_LINE_BUFFERED)
 return Lstream_write_1 (lstr, data, size);
-for (i = 0; i < (int) size; i++)
+for (i = 0; i < size; i++)
 {
 if (Lstream_putc (lstr, p[i]) < 0)
 	break;
 }
-return i == 0 ? -1 : 0;
+return i == 0 ? -1 : (ssize_t) i;
 }
 int
 Lstream_was_blocked_p (Lstream *lstr)
 {
-if (lstr->imp->was_blocked_p)
+return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
-return (lstr->imp->was_blocked_p) (lstr);
-else
-return 0;
 }
 static int
 Lstream_raw_read (Lstream *lstr, unsigned char *buffer, size_t size)
 {
 return (lstr->imp->reader) (lstr, buffer, size);
 }
 /* Assuming the buffer is empty, fill it up again. */
-static int
+static ssize_t
 Lstream_read_more (Lstream *lstr)
 {
 #if 0
-int size_needed = max (1, min (MAX_READ_SIZE, lstr->buffering_size));
+ssize_t size_needed = max (1, min (MAX_READ_SIZE, lstr->buffering_size));
 #else
 /* If someone requested a larger buffer size, so be it! */
-int size_needed = max (1, lstr->buffering_size);
+ssize_t size_needed = max (1, lstr->buffering_size);
 #endif
-int size_gotten;
+ssize_t 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;
 }
-int
+ssize_t
 Lstream_read (Lstream *lstr, void *data, size_t size)
 {
 unsigned char *p = (unsigned char *) data;
-int off = 0;
+size_t off = 0;
 size_t chunk;
 int error_occurred = 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 < (int) chunk; off++)
+for (; off < chunk; off++)
 	p[off] = lstr->unget_buffer[--lstr->unget_buffer_ind];
 lstr->byte_count += chunk;
 size -= chunk;
 }
 }
 /* If we need some more, try to get some more from the stream's end */
 if (size > 0)
 	{
-	  int retval = Lstream_read_more (lstr);
+	  ssize_t retval = Lstream_read_more (lstr);
 	  if (retval < 0)
 	    error_occurred = 1;
 	  if (retval <= 0)
 	    break;
 	}
 if ((lstr->flags & LSTREAM_FL_NO_PARTIAL_CHARS) && off > 0)
 {
 /* It's quite possible for us to get passed an incomplete
 	 character at the end.  We need to spit back that
 	 incomplete character. */
-CONST unsigned char *dataend = p + off - 1;
+const unsigned char *dataend = p + off - 1;
 /* Optimize the most common case. */
 if (!BYTE_ASCII_P (*dataend))
 	{
 	  /* Go back to the beginning of the last (and possibly partial)
 	     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)
 	    {
-	      int newoff = dataend - p;
+	      size_t 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 : off);
+return off == 0 && error_occurred ? -1 : (ssize_t) off;
 }
 void
-Lstream_unread (Lstream *lstr, CONST void *data, size_t size)
+Lstream_unread (Lstream *lstr, const void *data, size_t size)
 {
-int i;
+const unsigned char *p = (const unsigned char *) data;
-unsigned char *p = (unsigned char *) data;
 /* Make sure buffer is big enough */
 DO_REALLOC (lstr->unget_buffer, lstr->unget_buffer_size,
 	      lstr->unget_buffer_ind + size, unsigned char);
+lstr->byte_count -= size;
 /* Bytes have to go on in reverse order -- they are reversed
 again when read back. */
-for (i = size - 1; i >= 0; i--)
+while (size--)
-lstr->unget_buffer[lstr->unget_buffer_ind++] = p[i];
+lstr->unget_buffer[lstr->unget_buffer_ind++] = p[size];
-lstr->byte_count -= size;
 }
 int
 Lstream_rewind (Lstream *lstr)
 {
 }
 static int
 Lstream_pseudo_close (Lstream *lstr)
 {
-int rc;
 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 */
-rc = Lstream_flush (lstr);
+return Lstream_flush (lstr);
-return rc;
 }
 int
 Lstream_close (Lstream *lstr)
 {
 int
 Lstream_fputc (Lstream *lstr, int c)
 {
 unsigned char ch = (unsigned char) c;
-int retval = Lstream_write_1 (lstr, &ch, 1);
+ssize_t 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;
 }
 DEFINE_LSTREAM_IMPLEMENTATION ("stdio", lstream_stdio,
 			       sizeof (struct stdio_stream));
 static Lisp_Object
-make_stdio_stream_1 (FILE *stream, int flags, CONST char *mode)
+make_stdio_stream_1 (FILE *stream, int flags, const char *mode)
 {
 Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_stdio, mode);
 struct stdio_stream *str = STDIO_STREAM_DATA (lstr);
 str->file = stream;
 make_stdio_output_stream (FILE *stream, int flags)
 {
 return make_stdio_stream_1 (stream, flags, "w");
 }
-static int
+/* #### From reading the Unix 98 specification, it appears that if we
+want stdio_reader() to be completely correct, we should check for
+0 < val < size and if so, check to see if an error has occurred.
+If an error has occurred, but val is non-zero, we should go ahead
+and act as if the read was successful, but remember in some fashion
+or other, that an error has occurred, and report that on the next
+call to stdio_reader instead of calling fread() again.
+Currently, in such a case, we end up calling fread() twice and we
+assume that
+1) this is not harmful, and
+2) the error will still be reported on the second read.
+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
 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);
+size_t val = fread (data, 1, size, str->file);
 if (!val && ferror (str->file))
 return -1;
-return (int) val;
+return val;
 }
-static int
+static ssize_t
-stdio_writer (Lstream *stream, CONST unsigned char *data, size_t 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, str->file);
 if (!val && ferror (str->file))
 return -1;
-return (int) val;
+return val;
 }
 static int
 stdio_rewinder (Lstream *stream)
 {
 {
 struct stdio_stream *str = STDIO_STREAM_DATA (stream);
 if (stream->flags & LSTREAM_FL_WRITE)
 return fflush (str->file);
 else
-/* call fpurge?  Only exists on some systems.  #### Why not add a
-configure check for HAVE_FPURGE and utilize it on systems that
-support it?  --hniksic */
 return 0;
 }
 static int
 stdio_closer (Lstream *stream)
 return fclose (str->file);
 else
 if (stream->flags & LSTREAM_FL_WRITE)
 return fflush (str->file);
 else
-/* call fpurge?  Only exists on some systems. */
 return 0;
 }
 /*********** a file descriptor ***********/
 OFFSET is the offset from the *current* file pointer that the reading
 should start at.  COUNT is the number of bytes to be read (it is
 ignored when writing); -1 for unlimited. */
 static Lisp_Object
 make_filedesc_stream_1 (int filedesc, int offset, int count, int flags,
-			CONST char *mode)
+			const char *mode)
 {
 Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_filedesc, mode);
 struct filedesc_stream *fstr = FILEDESC_STREAM_DATA (lstr);
 fstr->fd = filedesc;
 make_filedesc_output_stream (int filedesc, int offset, int count, int flags)
 {
 return make_filedesc_stream_1 (filedesc, offset, count, flags, "w");
 }
-static int
+static ssize_t
 filedesc_reader (Lstream *stream, unsigned char *data, size_t size)
 {
-int nread;
+ssize_t 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));
-nread = (str->allow_quit ? read_allowing_quit : read) (str->fd, data, size);
+nread = str->allow_quit ?
+read_allowing_quit (str->fd, data, size) :
+read (str->fd, data, size);
 if (nread > 0)
 str->current_pos += nread;
 return nread;
 }
 return 1;
 #endif
 return 0;
 }
-static int
+static ssize_t
-filedesc_writer (Lstream *stream, CONST unsigned char *data, size_t size)
+filedesc_writer (Lstream *stream, const unsigned char *data, size_t size)
 {
 struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
-int retval;
+ssize_t 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?
 Maybe all the PTY crap here should be moved into another stream
 that does nothing but periodically insert EOF's as necessary. */
 if (str->pty_flushing)
 {
 /* To make life easy, only send out one line at the most. */
-CONST unsigned char *ptr;
+const unsigned char *ptr;
-ptr = (CONST unsigned char *) memchr (data, '\n', size);
+ptr = (const unsigned char *) memchr (data, '\n', size);
 if (ptr)
 	need_newline = 1;
 else
 	ptr = data + size;
 if (ptr - data >= str->pty_max_bytes - str->chars_sans_newline)
 size = ptr - data;
 }
 /**** start of non-PTY-crap ****/
 if (size > 0)
-retval = ((str->allow_quit ? write_allowing_quit : write)
+retval = str->allow_quit ?
-	      (str->fd, data, size));
+write_allowing_quit (str->fd, data, size) :
+write (str->fd, data, size);
 else
 retval = 0;
 if (retval < 0 && errno_would_block_p (errno) && str->blocked_ok)
 {
 str->blocking_error_p = 1;
 	 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)
 	{
-	  int retval2 = ((str->allow_quit ? write_allowing_quit : write)
+	  ssize_t retval2 = str->allow_quit ?
-			 (str->fd, &str->eof_char, 1));
+	    write_allowing_quit (str->fd, &str->eof_char, 1) :
+	    write (str->fd, &str->eof_char, 1);
 	  if (retval2 > 0)
 	    str->chars_sans_newline = 0;
 	  else if (retval2 < 0)
 	    {
 	      /* Error writing the EOF char.  If nothing got written,
 first byte is a newline, we'd get stuck never writing anything
 in pty-flushing mode. */
 if (need_newline)
 {
 Bufbyte nl = '\n';
-int retval2 = ((str->allow_quit ? write_allowing_quit : write)
+ssize_t retval2 = str->allow_quit ?
-		     (str->fd, &nl, 1));
+	write_allowing_quit (str->fd, &nl, 1) :
+	write (str->fd, &nl, 1);
 if (retval2 > 0)
 {
 str->chars_sans_newline = 0;
 retval++;
 }
 str->obj = string;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
-static int
+static ssize_t
 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));
 str->offset = pos;
 return 0;
 }
 static Lisp_Object
-lisp_string_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
+lisp_string_marker (Lisp_Object stream)
 {
 struct lisp_string_stream *str = LISP_STRING_STREAM_DATA (XLSTREAM (stream));
 return str->obj;
 }
 #define FIXED_BUFFER_STREAM_DATA(stream) \
 LSTREAM_TYPE_DATA (stream, fixed_buffer)
 struct fixed_buffer_stream
 {
-CONST unsigned char *inbuf;
+const unsigned char *inbuf;
 unsigned char *outbuf;
 size_t size;
 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, size_t size)
+make_fixed_buffer_input_stream (const void *buf, size_t size)
 {
 Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_fixed_buffer, "r");
 struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (lstr);
-str->inbuf = buf;
+str->inbuf = (const unsigned char *) buf;
 str->size = size;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
 Lisp_Object
-make_fixed_buffer_output_stream (unsigned char *buf, size_t size)
+make_fixed_buffer_output_stream (void *buf, size_t size)
 {
 Lisp_Object obj;
 Lstream *lstr = Lstream_new (lstream_fixed_buffer, "w");
 struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (lstr);
-str->outbuf = buf;
+str->outbuf = (unsigned char *) buf;
 str->size = size;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
-static int
+static ssize_t
 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
+static ssize_t
-fixed_buffer_writer (Lstream *stream, CONST unsigned char *data, size_t 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
 {
 FIXED_BUFFER_STREAM_DATA (stream)->offset = 0;
 return 0;
 }
-CONST unsigned char *
+const unsigned char *
 fixed_buffer_input_stream_ptr (Lstream *stream)
 {
 assert (stream->imp == lstream_fixed_buffer);
 return FIXED_BUFFER_STREAM_DATA (stream)->inbuf;
 }
 Lisp_Object obj;
 XSETLSTREAM (obj, Lstream_new (lstream_resizing_buffer, "w"));
 return obj;
 }
-static int
+static ssize_t
-resizing_buffer_writer (Lstream *stream, CONST unsigned char *data, size_t 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;
 XSETLSTREAM (obj, Lstream_new (lstream_dynarr, "w"));
 DYNARR_STREAM_DATA (XLSTREAM (obj))->dyn = dyn;
 return obj;
 }
-static int
+static ssize_t
-dynarr_writer (Lstream *stream, CONST unsigned char *data, size_t 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;
 }
 DEFINE_LSTREAM_IMPLEMENTATION ("lisp-buffer", lstream_lisp_buffer,
 			       sizeof (struct lisp_buffer_stream));
 static Lisp_Object
 make_lisp_buffer_stream_1 (struct buffer *buf, Bufpos start, Bufpos end,
-			   int flags, CONST char *mode)
+			   int flags, const char *mode)
 {
 Lisp_Object obj;
 Lstream *lstr;
 struct lisp_buffer_stream *str;
 Bufpos bmin, bmax;
 Lstream_set_character_mode (XLSTREAM (lstr));
 return lstr;
 }
-static int
+static ssize_t
 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;
 set_bi_marker_position (str->start, end);
 return data - orig_data;
 }
-static int
+static ssize_t
-lisp_buffer_writer (Lstream *stream, CONST unsigned char *data, size_t 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);
 set_marker_position (str->start, pos);
 return 0;
 }
 static Lisp_Object
-lisp_buffer_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
+lisp_buffer_marker (Lisp_Object stream)
 {
 struct lisp_buffer_stream *str =
 LISP_BUFFER_STREAM_DATA (XLSTREAM (stream));
-markobj (str->start);
+mark_object (str->start);
-markobj (str->end);
+mark_object (str->end);
 return str->buffer;
 }
 Bufpos
 lisp_buffer_stream_startpos (Lstream *stream)
 LSTREAM_HAS_METHOD (lisp_buffer, rewinder);
 LSTREAM_HAS_METHOD (lisp_buffer, marker);
 }
 void
+reinit_vars_of_lstream (void)
+{
+int i;
+for (i = 0; i < countof (Vlstream_free_list); i++)
+{
+Vlstream_free_list[i] = Qnil;
+staticpro_nodump (&Vlstream_free_list[i]);
+}
+}
+void
 vars_of_lstream (void)
 {
-int i;
+reinit_vars_of_lstream ();
+}
-for (i = 0; i < countof (Vlstream_free_list); i++)
-{
-Vlstream_free_list[i] = Qnil;
-staticpro (&Vlstream_free_list[i]);
-}
-}

Mercurial > hg > xemacs-beta

comparison src/lstream.c @ 398:74fd4e045ea6 r21-2-29