/usr/lib/xemacs-21.4.24/x86_64-linux-gnu/include/lstream.h is in xemacs21-bin 21.4.24-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 | /* Generic stream implementation -- header file.
Copyright (C) 1995 Free Software Foundation, Inc.
Copyright (C) 1996 Ben Wing.
This file is part of XEmacs.
XEmacs is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
XEmacs is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with XEmacs; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Synched up with: Not in FSF. */
/* Written by Ben Wing. */
#ifndef INCLUDED_lstream_h_
#define INCLUDED_lstream_h_
/************************************************************************/
/* definition of Lstream object */
/************************************************************************/
DECLARE_LRECORD (lstream, struct lstream);
#define XLSTREAM(x) XRECORD (x, lstream, struct lstream)
#define XSETLSTREAM(x, p) XSETRECORD (x, p, lstream)
#define LSTREAMP(x) RECORDP (x, lstream)
/* #define CHECK_LSTREAM(x) CHECK_RECORD (x, lstream)
Lstream pointers should never escape to the Lisp level, so
functions should not be doing this. */
#ifndef EOF
#define EOF (-1)
#endif
/* Typedef specifying a count of bytes in a data block to be written
out or read in, using Lstream_read(), Lstream_write(), and related
functions. This MUST BE SIGNED, since it also is used in functions
that return the number of bytes actually read to or written from in
an operation, and these functions can return -1 to signal error.
Note that the standard Unix read() and write() functions define the
count going in as a size_t, which is UNSIGNED, and the count going
out as an ssize_t, which is SIGNED. This is a horrible design
flaw. Not only is it highly likely to lead to logic errors when a
-1 gets interpreted as a large positive number, but operations are
bound to fail in all sorts of horrible ways when a number in the
upper-half of the size_t range is passed in -- this number is
unrepresentable as an ssize_t, so code that checks to see how many
bytes are actually written (which is mandatory if you are dealing
with certain types of devices) will get completely screwed up.
*/
typedef EMACS_INT Lstream_data_count;
typedef enum lstream_buffering
{
/* No buffering. */
LSTREAM_UNBUFFERED,
/* Buffer until a '\n' character is reached. */
LSTREAM_LINE_BUFFERED,
/* Buffer in standard-size (i.e. 512-byte) blocks. */
LSTREAM_BLOCK_BUFFERED,
/* Buffer in blocks of a specified size. */
LSTREAM_BLOCKN_BUFFERED,
/* Buffer until the stream is closed (only applies to write-only
streams). Only one call to the stream writer will be made,
and that is when the stream is closed. */
LSTREAM_UNLIMITED
} Lstream_buffering;
/* Methods defining how this stream works. Some may be undefined. */
/* We do not implement the seek/tell paradigm. I tried to do that,
but getting the semantics right in the presence of buffering is
extremely tricky and very error-prone and basically not worth it.
This is especially the case with complicated streams like
decoding streams -- the seek pointer in this case can't be a single
integer but has to be a whole complicated structure that records
all of the stream's state at the time.
Rewind semantics are generally easy to implement, so we do provide
a rewind method. Even rewind() may not be available on a stream,
however -- e.g. on process output. */
typedef struct lstream_implementation
{
const char *name;
Lstream_data_count size; /* Number of additional bytes to be
allocated with this stream. Access this
data using Lstream_data(). */
/* Read some data from the stream's end and store it into DATA, which
can hold SIZE bytes. Return the number of bytes read. A return
value of 0 means no bytes can be read at this time. This may
be because of an EOF, or because there is a granularity greater
than one byte that the stream imposes on the returned data, and
SIZE is less than this granularity. (This will happen frequently
for streams that need to return whole characters, because
Lstream_read() calls the reader function repeatedly until it
has the number of bytes it wants or until 0 is returned.)
The lstream functions do not treat a 0 return as EOF or do
anything special; however, the calling function will interpret
any 0 it gets back as EOF. This will normally not happen unless
the caller calls Lstream_read() with a very small size.
This function can be NULL if the stream is output-only. */
/* The omniscient mly, blinded by the irresistible thrall of Common
Lisp, thinks that it is bogus that the types and implementations
of input and output streams are the same. */
Lstream_data_count (*reader) (Lstream *stream, unsigned char *data,
Lstream_data_count size);
/* Send some data to the stream's end. Data to be sent is in DATA
and is SIZE bytes. Return the number of bytes sent. This
function can send and return fewer bytes than is passed in; in
that case, the function will just be called again until there is
no data left or 0 is returned. A return value of 0 means that no
more data can be currently stored, but there is no error; the
data will be squirrelled away until the writer can accept
data. (This is useful, e.g., of you're dealing with a
non-blocking file descriptor and are getting EWOULDBLOCK errors.)
This function can be NULL if the stream is input-only. */
Lstream_data_count (*writer) (Lstream *stream, const unsigned char *data,
Lstream_data_count size);
/* Return non-zero if the last write operation on the stream resulted
in an attempt to block (EWOULDBLOCK). If this method does not
exists, the implementation returns 0 */
int (*was_blocked_p) (Lstream *stream);
/* Rewind the stream. If this is NULL, the stream is not seekable. */
int (*rewinder) (Lstream *stream);
/* Indicate whether this stream is seekable -- i.e. it can be rewound.
This method is ignored if the stream does not have a rewind
method. If this method is not present, the result is determined
by whether a rewind method is present. */
int (*seekable_p) (Lstream *stream);
/* Perform any additional operations necessary to flush the
data in this stream. */
int (*flusher) (Lstream *stream);
/* Perform any additional operations necessary to close this
stream down. May be NULL. This function is called when
Lstream_close() is called or when the stream is garbage-
collected. When this function is called, all pending data
in the stream will already have been written out. */
int (*closer) (Lstream *stream);
/* Mark this object for garbage collection. Same semantics as
a standard Lisp_Object marker. This function can be NULL. */
Lisp_Object (*marker) (Lisp_Object lstream);
} Lstream_implementation;
#define DEFINE_LSTREAM_IMPLEMENTATION(name,c_name,size) \
Lstream_implementation c_name[1] = \
{ { (name), (size) } }
#define LSTREAM_FL_IS_OPEN 1
#define LSTREAM_FL_READ 2
#define LSTREAM_FL_WRITE 4
#define LSTREAM_FL_NO_PARTIAL_CHARS 8
#define LSTREAM_FL_CLOSE_AT_DISKSAVE 16
struct lstream
{
struct lcrecord_header header;
const Lstream_implementation *imp; /* methods for this stream */
Lstream_buffering buffering; /* type of buffering in use */
Lstream_data_count buffering_size; /* number of bytes buffered */
unsigned char *in_buffer; /* holds characters read from stream end */
Lstream_data_count in_buffer_size; /* allocated size of buffer */
Lstream_data_count in_buffer_current; /* number of characters in buffer */
Lstream_data_count in_buffer_ind; /* pointer to next character to
take from buffer */
unsigned char *out_buffer; /* holds characters to write to stream end */
Lstream_data_count out_buffer_size; /* allocated size of buffer */
Lstream_data_count out_buffer_ind; /* pointer to next buffer spot to
write a character */
/* The unget buffer is more or less a stack -- things get pushed
onto the end and read back from the end. Lstream_read()
basically reads backwards from the end to get stuff; Lstream_unread()
similarly has to push the data on backwards. */
unsigned char *unget_buffer; /* holds characters pushed back onto input */
Lstream_data_count unget_buffer_size; /* allocated size of buffer */
Lstream_data_count unget_buffer_ind; /* pointer to next buffer spot
to write a character */
Lstream_data_count byte_count;
int flags;
max_align_t data[1];
};
#define LSTREAM_TYPE_P(lstr, type) \
((lstr)->imp == lstream_##type)
#ifdef ERROR_CHECK_TYPECHECK
INLINE_HEADER struct lstream *
error_check_lstream_type (struct lstream *stream,
const Lstream_implementation *imp);
INLINE_HEADER struct lstream *
error_check_lstream_type (struct lstream *stream,
const Lstream_implementation *imp)
{
assert (stream->imp == imp);
return stream;
}
# define LSTREAM_TYPE_DATA(lstr, type) \
((struct type##_stream *) \
Lstream_data (error_check_lstream_type(lstr, lstream_##type)))
#else
# define LSTREAM_TYPE_DATA(lstr, type) \
((struct type##_stream *) Lstream_data (lstr))
#endif
/* Declare that lstream-type TYPE has method M; used in
initialization routines */
#define LSTREAM_HAS_METHOD(type, m) \
(lstream_##type->m = type##_##m)
Lstream *Lstream_new (const Lstream_implementation *imp,
const char *mode);
void Lstream_reopen (Lstream *lstr);
void Lstream_set_buffering (Lstream *lstr, Lstream_buffering buffering,
int buffering_size);
int Lstream_flush (Lstream *lstr);
int Lstream_flush_out (Lstream *lstr);
int Lstream_fputc (Lstream *lstr, int c);
int Lstream_fgetc (Lstream *lstr);
void Lstream_fungetc (Lstream *lstr, int c);
Lstream_data_count Lstream_read (Lstream *lstr, void *data,
Lstream_data_count size);
Lstream_data_count Lstream_write (Lstream *lstr, const void *data,
Lstream_data_count size);
int Lstream_was_blocked_p (Lstream *lstr);
void Lstream_unread (Lstream *lstr, const void *data, Lstream_data_count size);
int Lstream_rewind (Lstream *lstr);
int Lstream_seekable_p (Lstream *lstr);
int Lstream_close (Lstream *lstr);
void Lstream_delete (Lstream *lstr);
void Lstream_set_character_mode (Lstream *str);
/* Call the function equivalent if the out buffer is full. Otherwise,
add to the end of the out buffer and, if line buffering is called for
and the character marks the end of a line, write out the buffer. */
#define Lstream_putc(stream, c) \
((stream)->out_buffer_ind >= (stream)->out_buffer_size ? \
Lstream_fputc (stream, c) : \
((stream)->out_buffer[(stream)->out_buffer_ind++] = \
(unsigned char) (c), \
(stream)->byte_count++, \
(stream)->buffering == LSTREAM_LINE_BUFFERED && \
(stream)->out_buffer[(stream)->out_buffer_ind - 1] == '\n' ? \
Lstream_flush_out (stream) : 0))
/* Retrieve from unget buffer if there are any characters there;
else retrieve from in buffer if there's anything there;
else call the function equivalent */
#define Lstream_getc(stream) \
((stream)->unget_buffer_ind > 0 ? \
((stream)->byte_count++, \
(stream)->unget_buffer[--(stream)->unget_buffer_ind]) : \
(stream)->in_buffer_ind < (stream)->in_buffer_current ? \
((stream)->byte_count++, \
(stream)->in_buffer[(stream)->in_buffer_ind++]) : \
Lstream_fgetc (stream))
/* Add to the end if it won't overflow buffer; otherwise call the
function equivalent */
#define Lstream_ungetc(stream, c) \
((stream)->unget_buffer_ind >= (stream)->unget_buffer_size ? \
Lstream_fungetc (stream, c) : \
(void) ((stream)->byte_count--, \
((stream)->unget_buffer[(stream)->unget_buffer_ind++] = \
(unsigned char) (c))))
#define Lstream_data(stream) ((void *) ((stream)->data))
#define Lstream_byte_count(stream) ((stream)->byte_count)
/************************************************************************/
/* working with an Lstream as a stream of Emchars */
/************************************************************************/
#ifdef MULE
#ifndef BYTE_ASCII_P
#include "mule-charset.h"
#endif
INLINE_HEADER Emchar Lstream_get_emchar (Lstream *stream);
INLINE_HEADER Emchar
Lstream_get_emchar (Lstream *stream)
{
int c = Lstream_getc (stream);
return (c < 0x80 /* c == EOF || BYTE_ASCII_P (c) */
? (Emchar) c
: Lstream_get_emchar_1 (stream, c));
}
INLINE_HEADER int Lstream_put_emchar (Lstream *stream, Emchar ch);
INLINE_HEADER int
Lstream_put_emchar (Lstream *stream, Emchar ch)
{
return CHAR_ASCII_P (ch) ?
Lstream_putc (stream, ch) :
Lstream_fput_emchar (stream, ch);
}
INLINE_HEADER void Lstream_unget_emchar (Lstream *stream, Emchar ch);
INLINE_HEADER void
Lstream_unget_emchar (Lstream *stream, Emchar ch)
{
if (CHAR_ASCII_P (ch))
Lstream_ungetc (stream, ch);
else
Lstream_funget_emchar (stream, ch);
}
#else /* not MULE */
# define Lstream_get_emchar(stream) Lstream_getc (stream)
# define Lstream_put_emchar(stream, ch) Lstream_putc (stream, ch)
# define Lstream_unget_emchar(stream, ch) Lstream_ungetc (stream, ch)
#endif /* not MULE */
/************************************************************************/
/* Lstream implementations */
/************************************************************************/
/* Flags we can pass to the filedesc and stdio streams. */
/* If set, close the descriptor or FILE * when the stream is closed. */
#define LSTR_CLOSING 1
/* If set, allow quitting out of the actual I/O. */
#define LSTR_ALLOW_QUIT 2
/* If set and filedesc_stream_set_pty_flushing() has been called
on the stream, do not send more than pty_max_bytes on a single
line without flushing the data out using the eof_char. */
#define LSTR_PTY_FLUSHING 4
/* If set, an EWOULDBLOCK error is not treated as an error but
simply causes the write function to return 0 as the number
of bytes written out. */
#define LSTR_BLOCKED_OK 8
Lisp_Object make_stdio_input_stream (FILE *stream, int flags);
Lisp_Object make_stdio_output_stream (FILE *stream, int flags);
Lisp_Object make_filedesc_input_stream (int filedesc, int offset, int count,
int flags);
Lisp_Object make_filedesc_output_stream (int filedesc, int offset, int count,
int flags);
void filedesc_stream_set_pty_flushing (Lstream *stream,
int pty_max_bytes,
Bufbyte eof_char);
int filedesc_stream_fd (Lstream *stream);
Lisp_Object make_lisp_string_input_stream (Lisp_Object string,
Bytecount offset,
Bytecount len);
Lisp_Object make_fixed_buffer_input_stream (const void *buf,
Lstream_data_count size);
Lisp_Object make_fixed_buffer_output_stream (void *buf,
Lstream_data_count size);
const unsigned char *fixed_buffer_input_stream_ptr (Lstream *stream);
unsigned char *fixed_buffer_output_stream_ptr (Lstream *stream);
Lisp_Object make_resizing_buffer_output_stream (void);
unsigned char *resizing_buffer_stream_ptr (Lstream *stream);
Lisp_Object make_dynarr_output_stream (unsigned_char_dynarr *dyn);
#define LSTR_SELECTIVE 1
#define LSTR_IGNORE_ACCESSIBLE 2
Lisp_Object make_lisp_buffer_input_stream (struct buffer *buf, Bufpos start,
Bufpos end, int flags);
Lisp_Object make_lisp_buffer_output_stream (struct buffer *buf, Bufpos pos,
int flags);
Bufpos lisp_buffer_stream_startpos (Lstream *stream);
#endif /* INCLUDED_lstream_h_ */
|