xemacs-beta: src/lstream.c comparison

comparison src/lstream.c @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14

author	cvs
date	Mon, 13 Aug 2007 11:20:41 +0200
parents	de805c49cfc1
children	41dbb7a9d5f2

comparison

equal deleted inserted replaced

-:12e008d41344
+:697ef44129c6
 /* Written by Ben Wing. */
 #include <config.h>
 #include "lisp.h"
+#include <limits.h>
 #include "buffer.h"
 #include "insdel.h"
 #include "lstream.h"
 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.
-ssize_t Lstream_read (Lstream *stream, void *data, size_t 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.
-ssize_t Lstream_write (Lstream *stream, void *data, size_t 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, size_t size)
 #define DEFAULT_BLOCK_BUFFERING_SIZE 512
 #define MAX_READ_SIZE 512
 static Lisp_Object
-mark_lstream (Lisp_Object obj)
+mark_lstream (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 Lstream *lstr = XLSTREAM (obj);
-return lstr->imp->marker ? (lstr->imp->marker) (obj) : Qnil;
+return lstr->imp->marker ? (lstr->imp->marker) (obj, markobj) : 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, 0,
+					finalize_lstream, 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++)
 }
 #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)
 {
-ssize_t num_written;
+int num_written;
 while (lstr->out_buffer_ind > 0)
 {
-size_t size = lstr->out_buffer_ind;
+int 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 >= 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);
 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 int
 Lstream_adding (Lstream *lstr, size_t num, int force)
 {
-size_t size = num + lstr->out_buffer_ind;
+/* Compute the size that the outbuffer needs to be after the
+chars are added. */
-if (size <= lstr->out_buffer_size)
+size_t size_needed = max (lstr->out_buffer_size,
-return num;
+			    num + lstr->out_buffer_ind);
 /* Maybe chop it down so that we don't buffer more characters
 than our advertised buffering size. */
-if ((size > lstr->buffering_size) && !force)
+if (!force)
-{
+size_needed = min (lstr->buffering_size, size_needed);
-size = lstr->buffering_size;
+DO_REALLOC (lstr->out_buffer, lstr->out_buffer_size,
-/* There might be more data buffered than the buffering size. */
+	      size_needed, unsigned char);
-if (size <= lstr->out_buffer_ind)
+/* There might be more data buffered than the buffering size,
-	return 0;
+so make sure we don't return a negative number here. */
-}
+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 ssize_t
+static int
-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;
-ssize_t off = 0;
+int 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);
+	int 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. */
+line buffering. */
-ssize_t
+int
-Lstream_write (Lstream *lstr, const void *data, size_t size)
+Lstream_write (Lstream *lstr, CONST void *data, size_t size)
 {
-size_t i;
+int 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 < size; i++)
+for (i = 0; i < (int) size; i++)
 {
 if (Lstream_putc (lstr, p[i]) < 0)
 	break;
 }
-return i == 0 ? -1 : (ssize_t) i;
+return i == 0 ? -1 : 0;
 }
 int
 Lstream_was_blocked_p (Lstream *lstr)
 {
-return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
+if (lstr->imp->was_blocked_p)
+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 ssize_t
+static int
 Lstream_read_more (Lstream *lstr)
 {
 #if 0
-ssize_t size_needed = max (1, min (MAX_READ_SIZE, lstr->buffering_size));
+int 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);
+int size_needed = max (1, lstr->buffering_size);
 #endif
-ssize_t size_gotten;
+int 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
+int
 Lstream_read (Lstream *lstr, void *data, size_t size)
 {
 unsigned char *p = (unsigned char *) data;
-size_t off = 0;
+int 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 < chunk; off++)
+for (; off < (int) 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)
 	{
-	  ssize_t retval = Lstream_read_more (lstr);
+	  int 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)
 	    {
-	      size_t newoff = dataend - p;
+	      int 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, size_t size)
 {
-const unsigned char *p = (const unsigned char *) data;
+int i;
+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. */
-while (size--)
+for (i = size - 1; i >= 0; i--)
-lstr->unget_buffer[lstr->unget_buffer_ind++] = p[size];
+lstr->unget_buffer[lstr->unget_buffer_ind++] = p[i];
+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 */
-return Lstream_flush (lstr);
+rc = Lstream_flush (lstr);
+return rc;
 }
 int
 Lstream_close (Lstream *lstr)
 {
 int
 Lstream_fputc (Lstream *lstr, int c)
 {
 unsigned char ch = (unsigned char) c;
-ssize_t retval = Lstream_write_1 (lstr, &ch, 1);
+int 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");
 }
-/* #### From reading the Unix 98 specification, it appears that if we
+static int
-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, str->file);
+size_t val = fread (data, 1, (size_t) size, str->file);
 if (!val && ferror (str->file))
 return -1;
-return val;
+return (int) val;
 }
-static ssize_t
+static int
-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 val;
+return (int) 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 ssize_t
+static int
 filedesc_reader (Lstream *stream, unsigned char *data, size_t size)
 {
-ssize_t nread;
+int 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 ?
+nread = (str->allow_quit ? read_allowing_quit : read) (str->fd, data, size);
-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 ssize_t
+static int
-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);
-ssize_t retval;
+int 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 ?
+retval = ((str->allow_quit ? write_allowing_quit : write)
-write_allowing_quit (str->fd, data, size) :
+	      (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)
 	{
-	  ssize_t retval2 = str->allow_quit ?
+	  int retval2 = ((str->allow_quit ? write_allowing_quit : write)
-	    write_allowing_quit (str->fd, &str->eof_char, 1) :
+			 (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';
-ssize_t retval2 = str->allow_quit ?
+int retval2 = ((str->allow_quit ? write_allowing_quit : write)
-	write_allowing_quit (str->fd, &nl, 1) :
+		     (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 ssize_t
+static int
 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)
+lisp_string_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
 {
 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 void *buf, size_t size)
+make_fixed_buffer_input_stream (CONST unsigned char *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 = (const unsigned char *) buf;
+str->inbuf = buf;
 str->size = size;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
 Lisp_Object
-make_fixed_buffer_output_stream (void *buf, size_t size)
+make_fixed_buffer_output_stream (unsigned char *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 = (unsigned char *) buf;
+str->outbuf = buf;
 str->size = size;
 XSETLSTREAM (obj, lstr);
 return obj;
 }
-static ssize_t
+static int
 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 ssize_t
+static int
-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 ssize_t
+static int
-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 ssize_t
+static int
-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 ssize_t
+static int
 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 ssize_t
+static int
-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)
+lisp_buffer_marker (Lisp_Object stream, void (*markobj) (Lisp_Object))
 {
 struct lisp_buffer_stream *str =
 LISP_BUFFER_STREAM_DATA (XLSTREAM (stream));
-mark_object (str->start);
+markobj (str->start);
-mark_object (str->end);
+markobj (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)
+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]);
+staticpro (&Vlstream_free_list[i]);
 }
 }
-void
-vars_of_lstream (void)
-{
-INIT_LRECORD_IMPLEMENTATION (lstream);
-reinit_vars_of_lstream ();
-}

Mercurial > hg > xemacs-beta

comparison src/lstream.c @ 412:697ef44129c6 r21-2-14