xemacs-beta: src/lstream.c comparison

comparison src/lstream.c @ 647:b39c14581166

[xemacs-hg @ 2001-08-13 04:45:47 by ben] removal of unsigned, size_t, etc.

author	ben
date	Mon, 13 Aug 2001 04:46:48 +0000
parents	183866b06e0b
children	fdefd0186b75

comparison

equal deleted inserted replaced

-:00c54252fe4f
+:b39c14581166
 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.
-Lstream_data_count Lstream_read (Lstream *stream, void *data,
+Lstream_Data_Count Lstream_read (Lstream *stream, void *data,
-Lstream_data_count size)
+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.
-Lstream_data_count Lstream_write (Lstream *stream, void *data,
+Lstream_Data_Count Lstream_write (Lstream *stream, void *data,
-Lstream_data_count size)
+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, Lstream_data_count 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.
 	/* Just close. */
 	Lstream_close (lstr);
 }
 }
-inline static size_t
+inline static Memory_Count
-aligned_sizeof_lstream (size_t lstream_type_specific_size)
+aligned_sizeof_lstream (Memory_Count lstream_type_specific_size)
 {
 return ALIGN_SIZE (offsetof (Lstream, data) + lstream_type_specific_size,
 		     ALIGNOF (max_align_t));
 }
-static size_t
+static Memory_Count
 sizeof_lstream (const void *header)
 {
 return aligned_sizeof_lstream (((const Lstream *) header)->imp->size);
 }
 /* Attempt to flush out all of the buffered data for writing. */
 int
 Lstream_flush_out (Lstream *lstr)
 {
-Lstream_data_count num_written;
+Lstream_Data_Count num_written;
 while (lstr->out_buffer_ind > 0)
 {
-Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
-Lstream_adding (Lstream *lstr, Lstream_data_count num, int force)
+Lstream_adding (Lstream *lstr, Lstream_Data_Count num, int force)
 {
-Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
-Lstream_write_1 (Lstream *lstr, const void *data, Lstream_data_count size)
+Lstream_write_1 (Lstream *lstr, const void *data, Lstream_Data_Count size)
 {
 const unsigned char *p = (const unsigned char *) data;
-Lstream_data_count 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 */
-	Lstream_data_count 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. */
-Lstream_data_count
+Lstream_Data_Count
-Lstream_write (Lstream *lstr, const void *data, Lstream_data_count size)
+Lstream_write (Lstream *lstr, const void *data, Lstream_Data_Count size)
 {
-Lstream_data_count i;
+Lstream_Data_Count i;
 const unsigned char *p = (const unsigned char *) data;
 if (size == 0)
 return size;
 if (lstr->buffering != LSTREAM_LINE_BUFFERED)
 Lstream_was_blocked_p (Lstream *lstr)
 {
 return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
 }
-static Lstream_data_count
+static Lstream_Data_Count
 Lstream_raw_read (Lstream *lstr, unsigned char *buffer,
-		  Lstream_data_count size)
+		  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 Lstream_data_count
+static Lstream_Data_Count
 Lstream_read_more (Lstream *lstr)
 {
 #if 0
-Lstream_data_count size_needed
+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! */
-Lstream_data_count size_needed =
+Lstream_Data_Count size_needed =
 max (1, lstr->buffering_size);
 #endif
-Lstream_data_count 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;
 }
-Lstream_data_count
+Lstream_Data_Count
-Lstream_read (Lstream *lstr, void *data, Lstream_data_count size)
+Lstream_read (Lstream *lstr, void *data, Lstream_Data_Count size)
 {
 unsigned char *p = (unsigned char *) data;
-Lstream_data_count off = 0;
+Lstream_Data_Count off = 0;
-Lstream_data_count 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)
 	{
-	  Lstream_data_count 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)
 	    {
-	      Lstream_data_count 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 : off;
 }
 void
-Lstream_unread (Lstream *lstr, const void *data, Lstream_data_count 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;
-Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
-stdio_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)
+stdio_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size)
 {
 struct stdio_stream *str = STDIO_STREAM_DATA (stream);
-Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
 stdio_writer (Lstream *stream, const unsigned char *data,
-	      Lstream_data_count size)
+	      Lstream_Data_Count size)
 {
 struct stdio_stream *str = STDIO_STREAM_DATA (stream);
-Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
-filedesc_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)
+filedesc_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size)
 {
-Lstream_data_count nread;
+Lstream_Data_Count nread;
 struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
 if (str->end_pos >= 0)
-size = min (size, (Lstream_data_count) (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 Lstream_data_count
+static Lstream_Data_Count
 filedesc_writer (Lstream *stream, const unsigned char *data,
-		 Lstream_data_count size)
+		 Lstream_Data_Count size)
 {
 struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
-Lstream_data_count 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)
 	{
-	  Lstream_data_count 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';
-Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
 lisp_string_reader (Lstream *stream, unsigned char *data,
-		    Lstream_data_count size)
+		    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, (Lstream_data_count) (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;
-Lstream_data_count size;
+Lstream_Data_Count size;
-Lstream_data_count 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, Lstream_data_count 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, Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
 fixed_buffer_reader (Lstream *stream, unsigned char *data,
-		     Lstream_data_count size)
+		     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 Lstream_data_count
+static Lstream_Data_Count
 fixed_buffer_writer (Lstream *stream, const unsigned char *data,
-		     Lstream_data_count size)
+		     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;
-Lstream_data_count 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 Lstream_data_count
+static Lstream_Data_Count
 resizing_buffer_writer (Lstream *stream, const unsigned char *data,
-			Lstream_data_count size)
+			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 Lstream_data_count
+static Lstream_Data_Count
 dynarr_writer (Lstream *stream, const unsigned char *data,
-	       Lstream_data_count size)
+	       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 Lstream_data_count
+static Lstream_Data_Count
 lisp_buffer_reader (Lstream *stream, unsigned char *data,
-		    Lstream_data_count size)
+		    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, (Lstream_data_count) (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 Lstream_data_count
+static Lstream_Data_Count
 lisp_buffer_writer (Lstream *stream, const unsigned char *data,
-		    Lstream_data_count size)
+		    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 @ 647:b39c14581166