xemacs-beta: src/lstream.c comparison

comparison src/lstream.c @ 442:abe6d1db359e r21-2-36

Import from CVS: tag r21-2-36

author	cvs
date	Mon, 13 Aug 2007 11:35:02 +0200
parents	8de8e3f6228a
children	576fb035e263

comparison

equal deleted inserted replaced

-:72a7cfa4a488
+:abe6d1db359e
 /* 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).
 	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,
 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);
 }
 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)
 }
 /* Like Lstream_write(), but does not handle line-buffering correctly. */
 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;
 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);
 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_write (Lstream *lstr, CONST void *data, size_t size)
+Lstream_write (Lstream *lstr, const void *data, size_t size)
 {
 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);
 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
 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)
 {
-CONST unsigned char *p = (CONST unsigned char *) data;
+const unsigned char *p = (const 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);
 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;
 return -1;
 return val;
 }
 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;
 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;
 #endif
 return 0;
 }
 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);
 ssize_t retval;
 int need_newline = 0;
 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)
 #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 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 = (const unsigned char *) buf;
 str->offset += size;
 return size;
 }
 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;
 }
 XSETLSTREAM (obj, Lstream_new (lstream_resizing_buffer, "w"));
 return obj;
 }
 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;
 DYNARR_STREAM_DATA (XLSTREAM (obj))->dyn = dyn;
 return obj;
 }
 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;
 set_bi_marker_position (str->start, end);
 return data - orig_data;
 }
 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);
 }
 void
 vars_of_lstream (void)
 {
+INIT_LRECORD_IMPLEMENTATION (lstream);
 reinit_vars_of_lstream ();
 }

Mercurial > hg > xemacs-beta

comparison src/lstream.c @ 442:abe6d1db359e r21-2-36