0 on success, -1 on error.
int Lstream_getc (Lstream *stream)
- Read one byte from the stream. This is a macro and so it
- is very efficient. The STREAM argument is evaluated more
- than once. Return value is -1 for EOF or error.
+ Read one byte from the stream and returns it as an unsigned
+ char cast to an int, or EOF on end of file or error.
+ This is a macro and so it is very efficient. The STREAM
+ argument is evaluated more than once.
void Lstream_ungetc (Lstream *stream, int c)
- Push one byte back onto the input queue. This will be the
- next byte read from the stream. Any number of bytes can be
- pushed back and will be read in the reverse order they were
- pushed back -- most recent first. (This is necessary for
- consistency -- if there are a number of bytes that have been
- unread and I read and unread a byte, it needs to be the first
- to be read again.) This is a macro and so it is very
- efficient. The C argument is only evaluated once but the
- STREAM argument is evaluated more than once.
+ Push one byte back onto the input queue, cast to unsigned char.
+ This will be the next byte read from the stream. Any number
+ of bytes can be pushed back and will be read in the reverse
+ order they were pushed back -- most recent first. (This is
+ necessary for consistency -- if there are a number of bytes
+ that have been unread and I read and unread a byte, it needs
+ to be the first to be read again.) This is a macro and so it
+ is very efficient. The C argument is only evaluated once but
+ the STREAM argument is evaluated more than once.
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)
+Lstream_data_count Lstream_read (Lstream *stream, void *data,
+ 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.
-ssize_t Lstream_write (Lstream *stream, void *data, size_t size)
+Lstream_data_count Lstream_write (Lstream *stream, void *data,
+ 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, size_t 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
}
}
+inline static size_t
+aligned_sizeof_lstream (size_t lstream_type_specific_size)
+{
+ return ALIGN_SIZE (offsetof (Lstream, data) + lstream_type_specific_size,
+ ALIGNOF (max_align_t));
+}
+
static size_t
sizeof_lstream (const void *header)
{
- const Lstream *lstr = (const Lstream *) header;
- return sizeof (*lstr) + lstr->imp->size - 1;
+ return aligned_sizeof_lstream (((const Lstream *) header)->imp->size);
}
DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("stream", lstream,
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,
+ make_lcrecord_list (aligned_sizeof_lstream (imp->size),
&lrecord_lstream);
lstream_type_count++;
}
p = XLSTREAM (allocate_managed_lcrecord (Vlstream_free_list[i]));
/* Zero it out, except the header. */
- memset ((char *) p + sizeof (p->header), 0,
- sizeof (*p) - sizeof (p->header) + imp->size - 1);
+ memset ((char *) p + sizeof (p->header), '\0',
+ aligned_sizeof_lstream (imp->size) - sizeof (p->header));
p->imp = imp;
Lstream_set_buffering (p, LSTREAM_BLOCK_BUFFERED, 0);
p->flags = LSTREAM_FL_IS_OPEN;
}
}
- abort ();
+ ABORT ();
}
#define Lstream_internal_error(reason, lstr) \
int
Lstream_flush_out (Lstream *lstr)
{
- ssize_t num_written;
+ Lstream_data_count num_written;
while (lstr->out_buffer_ind > 0)
{
- size_t 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))
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
-Lstream_adding (Lstream *lstr, size_t num, int force)
+static Lstream_data_count
+Lstream_adding (Lstream *lstr, Lstream_data_count num, int force)
{
- size_t size = num + lstr->out_buffer_ind;
+ Lstream_data_count size = num + lstr->out_buffer_ind;
if (size <= lstr->out_buffer_size)
return num;
/* Like Lstream_write(), but does not handle line-buffering correctly. */
-static ssize_t
-Lstream_write_1 (Lstream *lstr, const void *data, size_t size)
+static Lstream_data_count
+Lstream_write_1 (Lstream *lstr, const void *data, Lstream_data_count size)
{
const unsigned char *p = (const unsigned char *) data;
- ssize_t 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))
while (1)
{
/* Figure out how much we can add to the buffer */
- size_t chunk = Lstream_adding (lstr, size, 0);
+ Lstream_data_count chunk = Lstream_adding (lstr, size, 0);
if (chunk == 0)
{
if (couldnt_write_last_time)
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_data_count
+Lstream_write (Lstream *lstr, const void *data, Lstream_data_count size)
{
- size_t i;
+ Lstream_data_count i;
const unsigned char *p = (const unsigned char *) data;
if (size == 0)
if (Lstream_putc (lstr, p[i]) < 0)
break;
}
- return i == 0 ? -1 : (ssize_t) i;
+ return i == 0 ? -1 : i;
}
int
return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0;
}
-static int
-Lstream_raw_read (Lstream *lstr, unsigned char *buffer, size_t size)
+static Lstream_data_count
+Lstream_raw_read (Lstream *lstr, unsigned char *buffer,
+ Lstream_data_count size)
{
if (! (lstr->flags & LSTREAM_FL_IS_OPEN))
Lstream_internal_error ("lstream not open", lstr);
/* Assuming the buffer is empty, fill it up again. */
-static ssize_t
+static Lstream_data_count
Lstream_read_more (Lstream *lstr)
{
#if 0
- ssize_t size_needed = max (1, min (MAX_READ_SIZE, lstr->buffering_size));
+ 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! */
- ssize_t size_needed = max (1, lstr->buffering_size);
+ Lstream_data_count size_needed =
+ max (1, lstr->buffering_size);
#endif
- ssize_t size_gotten;
+ Lstream_data_count size_gotten;
DO_REALLOC (lstr->in_buffer, lstr->in_buffer_size,
size_needed, unsigned char);
return size_gotten < 0 ? -1 : size_gotten;
}
-ssize_t
-Lstream_read (Lstream *lstr, void *data, size_t size)
+Lstream_data_count
+Lstream_read (Lstream *lstr, void *data, Lstream_data_count size)
{
unsigned char *p = (unsigned char *) data;
- size_t off = 0;
- size_t chunk;
+ Lstream_data_count off = 0;
+ Lstream_data_count chunk;
int error_occurred = 0;
if (size == 0)
/* 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);
+ Lstream_data_count retval = Lstream_read_more (lstr);
if (retval < 0)
error_occurred = 1;
if (retval <= 0)
VALIDATE_CHARPTR_BACKWARD (dataend);
if (dataend + REP_BYTES_BY_FIRST_BYTE (*dataend) != p + off)
{
- size_t 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);
}
}
- 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, Lstream_data_count size)
{
const unsigned char *p = (const unsigned char *) data;
static int
Lstream_pseudo_close (Lstream *lstr)
{
- if (!lstr->flags & LSTREAM_FL_IS_OPEN)
+ 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 */
Lstream_fputc (Lstream *lstr, int c)
{
unsigned char ch = (unsigned char) c;
- ssize_t 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;
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)
+static Lstream_data_count
+stdio_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)
{
struct stdio_stream *str = STDIO_STREAM_DATA (stream);
- size_t 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 ssize_t
-stdio_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+stdio_writer (Lstream *stream, const unsigned char *data,
+ Lstream_data_count size)
{
struct stdio_stream *str = STDIO_STREAM_DATA (stream);
- size_t 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;
return make_filedesc_stream_1 (filedesc, offset, count, flags, "w");
}
-static ssize_t
-filedesc_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+filedesc_reader (Lstream *stream, unsigned char *data, Lstream_data_count size)
{
- ssize_t nread;
+ Lstream_data_count 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));
+ 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);
return 0;
}
-static ssize_t
-filedesc_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+filedesc_writer (Lstream *stream, const unsigned char *data,
+ Lstream_data_count size)
{
struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream);
- ssize_t retval;
+ Lstream_data_count retval;
int need_newline = 0;
/* This function would be simple if it were not for the blasted
out for EWOULDBLOCK. */
if (str->chars_sans_newline >= str->pty_max_bytes)
{
- ssize_t 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 (need_newline)
{
Bufbyte nl = '\n';
- ssize_t retval2 = str->allow_quit ?
+ Lstream_data_count retval2 = str->allow_quit ?
write_allowing_quit (str->fd, &nl, 1) :
write (str->fd, &nl, 1);
return obj;
}
-static ssize_t
-lisp_string_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+lisp_string_reader (Lstream *stream, unsigned char *data,
+ Lstream_data_count size)
{
struct lisp_string_stream *str = LISP_STRING_STREAM_DATA (stream);
/* Don't lose if the string shrank past us ... */
if (stream->flags & LSTREAM_FL_NO_PARTIAL_CHARS)
VALIDATE_CHARPTR_BACKWARD (start);
offset = start - strstart;
- size = min (size, (size_t) (str->end - offset));
+ size = min (size, (Lstream_data_count) (str->end - offset));
memcpy (data, start, size);
str->offset = offset + size;
return size;
{
const unsigned char *inbuf;
unsigned char *outbuf;
- size_t size;
- size_t offset;
+ Lstream_data_count size;
+ 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, size_t size)
+make_fixed_buffer_input_stream (const void *buf, Lstream_data_count size)
{
Lisp_Object obj;
Lstream *lstr = Lstream_new (lstream_fixed_buffer, "r");
}
Lisp_Object
-make_fixed_buffer_output_stream (void *buf, size_t size)
+make_fixed_buffer_output_stream (void *buf, Lstream_data_count size)
{
Lisp_Object obj;
Lstream *lstr = Lstream_new (lstream_fixed_buffer, "w");
return obj;
}
-static ssize_t
-fixed_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+fixed_buffer_reader (Lstream *stream, unsigned char *data,
+ Lstream_data_count size)
{
struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream);
size = min (size, str->size - str->offset);
return size;
}
-static ssize_t
-fixed_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+fixed_buffer_writer (Lstream *stream, const unsigned char *data,
+ Lstream_data_count size)
{
struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream);
if (str->offset == str->size)
struct resizing_buffer_stream
{
unsigned char *buf;
- size_t allocked;
+ Lstream_data_count allocked;
int max_stored;
int stored;
};
return obj;
}
-static ssize_t
-resizing_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+resizing_buffer_writer (Lstream *stream, const unsigned char *data,
+ 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);
return obj;
}
-static ssize_t
-dynarr_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+dynarr_writer (Lstream *stream, const unsigned char *data,
+ Lstream_data_count size)
{
struct dynarr_stream *str = DYNARR_STREAM_DATA (stream);
Dynarr_add_many (str->dyn, data, size);
/* Make sure the luser didn't pass "w" in. */
if (!strcmp (mode, "w"))
- abort ();
+ ABORT ();
if (flags & LSTR_IGNORE_ACCESSIBLE)
{
return lstr;
}
-static ssize_t
-lisp_buffer_reader (Lstream *stream, unsigned char *data, size_t size)
+static Lstream_data_count
+lisp_buffer_reader (Lstream *stream, unsigned char *data,
+ Lstream_data_count size)
{
struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
unsigned char *orig_data = data;
BI_BUF_ZV (buf));
}
- size = min (size, (size_t) (end - start));
+ size = min (size, (Lstream_data_count) (end - start));
end = start + size;
/* We cannot return a partial character. */
VALIDATE_BYTIND_BACKWARD (buf, end);
return data - orig_data;
}
-static ssize_t
-lisp_buffer_writer (Lstream *stream, const unsigned char *data, size_t size)
+static Lstream_data_count
+lisp_buffer_writer (Lstream *stream, const unsigned char *data,
+ Lstream_data_count size)
{
struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
Bufpos pos;
projects / chise / xemacs-chise.git.1 / blobdiff