Mercurial > hg > xemacs-beta
annotate src/lstream.h @ 5750:66d2f63df75f
Correct some spelling and formatting in behavior.el.
Mentioned in tracker issue 826, the third thing mentioned there (the file
name at the bottom of the file) had already been fixed.
lisp/ChangeLog addition:
2013-08-05 Aidan Kehoe <kehoea@parhasard.net>
* behavior.el:
(override-behavior):
Correct some spelling and formatting here, thank you Steven
Mitchell in tracker issue 826.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Mon, 05 Aug 2013 10:05:32 +0100 |
| parents | 2dbefd79b3d3 |
| children | 65d65b52d608 |
| rev | line source |
|---|---|
| 428 | 1 /* Generic stream implementation -- header file. |
| 2 Copyright (C) 1995 Free Software Foundation, Inc. | |
| 788 | 3 Copyright (C) 1996, 2001, 2002 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5127
diff
changeset
|
7 XEmacs is free software: you can redistribute it and/or modify it |
| 428 | 8 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5127
diff
changeset
|
9 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5127
diff
changeset
|
10 option) any later version. |
| 428 | 11 |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5127
diff
changeset
|
18 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 428 | 19 |
| 20 /* Synched up with: Not in FSF. */ | |
| 21 | |
| 22 /* Written by Ben Wing. */ | |
| 23 | |
| 440 | 24 #ifndef INCLUDED_lstream_h_ |
| 25 #define INCLUDED_lstream_h_ | |
| 428 | 26 |
| 27 /************************************************************************/ | |
| 28 /* definition of Lstream object */ | |
| 29 /************************************************************************/ | |
| 30 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
3017
diff
changeset
|
31 DECLARE_LISP_OBJECT (lstream, struct lstream); |
| 428 | 32 #define XLSTREAM(x) XRECORD (x, lstream, struct lstream) |
| 617 | 33 #define wrap_lstream(p) wrap_record (p, lstream) |
| 428 | 34 #define LSTREAMP(x) RECORDP (x, lstream) |
| 35 /* #define CHECK_LSTREAM(x) CHECK_RECORD (x, lstream) | |
| 36 Lstream pointers should never escape to the Lisp level, so | |
| 37 functions should not be doing this. */ | |
| 38 | |
| 39 #ifndef EOF | |
| 40 #define EOF (-1) | |
| 41 #endif | |
| 42 | |
| 771 | 43 /* There have been some arguments over the what the type should be that |
| 665 | 44 specifies a count of bytes in a data block to be written out or read in, |
| 45 using Lstream_read(), Lstream_write(), and related functions. | |
| 46 Originally it was long, which worked fine; Martin "corrected" these to | |
| 47 size_t and ssize_t on the grounds that this is theoretically cleaner and | |
| 48 is in keeping with the C standards. Unfortunately, this practice is | |
| 49 horribly error-prone due to design flaws in the way that mixed | |
| 50 signed/unsigned arithmetic happens. In fact, by doing this change, | |
| 51 Martin introduced a subtle but fatal error that caused the operation of | |
| 52 sending large mail messages to the SMTP server under Windows to fail. | |
| 53 By putting all values back to be signed, avoiding any signed/unsigned | |
| 54 mixing, the bug immediately went away. The type then in use was | |
| 55 Lstream_Data_Count, so that it be reverted cleanly if a vote came to | |
| 56 that. Now it is Bytecount. | |
| 57 | |
| 58 Some earlier comments about why the type must be signed: This MUST BE | |
| 59 SIGNED, since it also is used in functions that return the number of | |
| 60 bytes actually read to or written from in an operation, and these | |
| 61 functions can return -1 to signal error. | |
| 462 | 62 |
| 63 Note that the standard Unix read() and write() functions define the | |
| 64 count going in as a size_t, which is UNSIGNED, and the count going | |
| 65 out as an ssize_t, which is SIGNED. This is a horrible design | |
| 66 flaw. Not only is it highly likely to lead to logic errors when a | |
| 67 -1 gets interpreted as a large positive number, but operations are | |
| 68 bound to fail in all sorts of horrible ways when a number in the | |
| 69 upper-half of the size_t range is passed in -- this number is | |
| 70 unrepresentable as an ssize_t, so code that checks to see how many | |
| 71 bytes are actually written (which is mandatory if you are dealing | |
| 72 with certain types of devices) will get completely screwed up. | |
| 771 | 73 |
| 665 | 74 --ben |
| 462 | 75 */ |
| 428 | 76 typedef enum lstream_buffering |
| 77 { | |
| 78 /* No buffering. */ | |
| 79 LSTREAM_UNBUFFERED, | |
| 80 /* Buffer until a '\n' character is reached. */ | |
| 81 LSTREAM_LINE_BUFFERED, | |
| 82 /* Buffer in standard-size (i.e. 512-byte) blocks. */ | |
| 83 LSTREAM_BLOCK_BUFFERED, | |
| 84 /* Buffer in blocks of a specified size. */ | |
| 85 LSTREAM_BLOCKN_BUFFERED, | |
| 86 /* Buffer until the stream is closed (only applies to write-only | |
| 87 streams). Only one call to the stream writer will be made, | |
| 88 and that is when the stream is closed. */ | |
| 89 LSTREAM_UNLIMITED | |
| 90 } Lstream_buffering; | |
| 91 | |
| 771 | 92 #if 0 |
| 93 | |
| 94 /* #### not currently implemented; correct EOF handling is quite tricky | |
| 95 in the presence of various levels of filtering streams, and simply | |
| 96 interpreting 0 as EOF works fairly well as long as the amount of | |
| 97 data you're attempting to read is large and you know whether the | |
| 98 source stream at the end of the chain is a pipe (or other blocking | |
| 99 source) or not. we really should fix this, though. */ | |
| 100 | |
| 101 /* Return values from Lstream_read(). We do NOT use the C lib trick | |
| 102 of returning 0 to maybe indicate EOF because that is simply too | |
| 103 random and error-prone. It is quite legitimate for there to be no | |
| 104 data available but no EOF, even when not in the presence of | |
| 105 non-blocking I/O. For example, decoding/encoding streams (and in | |
| 106 general, any type of filtering stream) may only be able to return | |
| 107 data after a certain amount of data on the other end is | |
| 108 available. */ | |
| 109 | |
| 110 #define LSTREAM_EOF -2 | |
| 111 | |
| 112 #endif /* 0 */ | |
| 113 | |
| 114 #define LSTREAM_ERROR -1 | |
| 115 | |
| 428 | 116 /* Methods defining how this stream works. Some may be undefined. */ |
| 117 | |
| 118 /* We do not implement the seek/tell paradigm. I tried to do that, | |
| 119 but getting the semantics right in the presence of buffering is | |
| 120 extremely tricky and very error-prone and basically not worth it. | |
| 121 This is especially the case with complicated streams like | |
| 122 decoding streams -- the seek pointer in this case can't be a single | |
| 123 integer but has to be a whole complicated structure that records | |
| 124 all of the stream's state at the time. | |
| 125 | |
| 126 Rewind semantics are generally easy to implement, so we do provide | |
| 127 a rewind method. Even rewind() may not be available on a stream, | |
| 128 however -- e.g. on process output. */ | |
| 129 | |
| 130 typedef struct lstream_implementation | |
| 131 { | |
| 442 | 132 const char *name; |
| 665 | 133 Bytecount size; /* Number of additional bytes to be |
| 814 | 134 allocated with this stream. Access this |
| 135 data using Lstream_data(). */ | |
| 1204 | 136 |
| 137 /* Description of the extra data (struct foo_lstream) attached to a | |
| 138 coding system. */ | |
| 139 const struct sized_memory_description *extra_description; | |
| 140 | |
| 428 | 141 /* Read some data from the stream's end and store it into DATA, which |
| 142 can hold SIZE bytes. Return the number of bytes read. A return | |
| 143 value of 0 means no bytes can be read at this time. This may | |
| 144 be because of an EOF, or because there is a granularity greater | |
| 145 than one byte that the stream imposes on the returned data, and | |
| 146 SIZE is less than this granularity. (This will happen frequently | |
| 147 for streams that need to return whole characters, because | |
| 148 Lstream_read() calls the reader function repeatedly until it | |
| 149 has the number of bytes it wants or until 0 is returned.) | |
| 150 The lstream functions do not treat a 0 return as EOF or do | |
| 151 anything special; however, the calling function will interpret | |
| 152 any 0 it gets back as EOF. This will normally not happen unless | |
| 153 the caller calls Lstream_read() with a very small size. | |
| 154 | |
| 155 This function can be NULL if the stream is output-only. */ | |
| 442 | 156 /* The omniscient mly, blinded by the irresistible thrall of Common |
| 428 | 157 Lisp, thinks that it is bogus that the types and implementations |
| 158 of input and output streams are the same. */ | |
| 665 | 159 Bytecount (*reader) (Lstream *stream, unsigned char *data, |
| 814 | 160 Bytecount size); |
| 428 | 161 /* Send some data to the stream's end. Data to be sent is in DATA |
| 162 and is SIZE bytes. Return the number of bytes sent. This | |
| 163 function can send and return fewer bytes than is passed in; in | |
| 164 that case, the function will just be called again until there is | |
| 165 no data left or 0 is returned. A return value of 0 means that no | |
| 166 more data can be currently stored, but there is no error; the | |
| 167 data will be squirrelled away until the writer can accept | |
| 168 data. (This is useful, e.g., of you're dealing with a | |
| 169 non-blocking file descriptor and are getting EWOULDBLOCK errors.) | |
| 170 This function can be NULL if the stream is input-only. */ | |
| 665 | 171 Bytecount (*writer) (Lstream *stream, const unsigned char *data, |
| 814 | 172 Bytecount size); |
| 428 | 173 /* Return non-zero if the last write operation on the stream resulted |
| 174 in an attempt to block (EWOULDBLOCK). If this method does not | |
| 175 exists, the implementation returns 0 */ | |
| 176 int (*was_blocked_p) (Lstream *stream); | |
| 177 /* Rewind the stream. If this is NULL, the stream is not seekable. */ | |
| 178 int (*rewinder) (Lstream *stream); | |
| 179 /* Indicate whether this stream is seekable -- i.e. it can be rewound. | |
| 180 This method is ignored if the stream does not have a rewind | |
| 181 method. If this method is not present, the result is determined | |
| 182 by whether a rewind method is present. */ | |
| 183 int (*seekable_p) (Lstream *stream); | |
| 184 /* Perform any additional operations necessary to flush the | |
| 185 data in this stream. */ | |
| 186 int (*flusher) (Lstream *stream); | |
| 771 | 187 /* Perform any additional operations necessary to close this stream down. |
| 188 May be NULL. This function is called when Lstream_close() is called | |
| 189 (which will be called automatically on any open streams when they are | |
| 190 garbage-collected or deleted with Lstream_delete()). When this | |
| 191 function is called, all pending data in the stream will already have | |
| 192 been written out; however, the closer write more data, e.g. an "end" | |
| 193 section at the end of a file. */ | |
| 428 | 194 int (*closer) (Lstream *stream); |
| 771 | 195 /* Clean up any remaining data at the time that a stream is |
| 196 garbage-collected or deleted with Lstream_delete(). If the stream was | |
| 197 open at this point, the finalizer is called after calling | |
| 198 Lstream_close(). Called only once (NOT called at disksave time). */ | |
| 199 void (*finalizer) (Lstream *stream); | |
| 428 | 200 /* Mark this object for garbage collection. Same semantics as |
| 201 a standard Lisp_Object marker. This function can be NULL. */ | |
| 202 Lisp_Object (*marker) (Lisp_Object lstream); | |
| 203 } Lstream_implementation; | |
| 204 | |
| 771 | 205 #define DEFINE_LSTREAM_IMPLEMENTATION(name, c_name) \ |
| 206 Lstream_implementation lstream_##c_name[1] = \ | |
| 1204 | 207 { { (name), sizeof (struct c_name##_stream), \ |
| 208 &lstream_empty_extra_description } } | |
| 209 | |
| 210 #define DEFINE_LSTREAM_IMPLEMENTATION_WITH_DATA(name, c_name) \ | |
| 211 static const struct sized_memory_description c_name##_lstream_description_0 \ | |
| 212 = { \ | |
| 213 sizeof (struct c_name##_stream), \ | |
| 214 c_name##_lstream_description \ | |
| 215 }; \ | |
| 216 Lstream_implementation lstream_##c_name[1] = \ | |
| 217 { { (name), sizeof (struct c_name##_stream), \ | |
| 218 &c_name##_lstream_description_0 } } | |
| 771 | 219 |
| 220 #define DECLARE_LSTREAM(c_name) \ | |
| 221 extern Lstream_implementation lstream_##c_name[] | |
| 428 | 222 |
| 223 #define LSTREAM_FL_IS_OPEN 1 | |
| 224 #define LSTREAM_FL_READ 2 | |
| 225 #define LSTREAM_FL_WRITE 4 | |
| 226 #define LSTREAM_FL_NO_PARTIAL_CHARS 8 | |
| 227 #define LSTREAM_FL_CLOSE_AT_DISKSAVE 16 | |
| 228 | |
| 229 struct lstream | |
| 230 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
231 NORMAL_LISP_OBJECT_HEADER header; |
| 442 | 232 const Lstream_implementation *imp; /* methods for this stream */ |
| 428 | 233 Lstream_buffering buffering; /* type of buffering in use */ |
| 665 | 234 Bytecount buffering_size; /* number of bytes buffered */ |
| 428 | 235 |
| 236 unsigned char *in_buffer; /* holds characters read from stream end */ | |
| 665 | 237 Bytecount in_buffer_size; /* allocated size of buffer */ |
| 238 Bytecount in_buffer_current; /* number of characters in buffer */ | |
| 239 Bytecount in_buffer_ind; /* pointer to next character to | |
| 462 | 240 take from buffer */ |
| 428 | 241 |
| 242 unsigned char *out_buffer; /* holds characters to write to stream end */ | |
| 665 | 243 Bytecount out_buffer_size; /* allocated size of buffer */ |
| 244 Bytecount out_buffer_ind; /* pointer to next buffer spot to | |
| 462 | 245 write a character */ |
| 428 | 246 |
| 247 /* The unget buffer is more or less a stack -- things get pushed | |
| 248 onto the end and read back from the end. Lstream_read() | |
| 249 basically reads backwards from the end to get stuff; Lstream_unread() | |
| 250 similarly has to push the data on backwards. */ | |
| 251 unsigned char *unget_buffer; /* holds characters pushed back onto input */ | |
| 665 | 252 Bytecount unget_buffer_size; /* allocated size of buffer */ |
| 253 Bytecount unget_buffer_ind; /* pointer to next buffer spot | |
| 462 | 254 to write a character */ |
| 428 | 255 |
| 665 | 256 Bytecount byte_count; |
| 456 | 257 int flags; |
| 258 max_align_t data[1]; | |
| 428 | 259 }; |
| 260 | |
| 1204 | 261 extern const struct sized_memory_description lstream_empty_extra_description; |
| 262 | |
| 428 | 263 #define LSTREAM_TYPE_P(lstr, type) \ |
| 264 ((lstr)->imp == lstream_##type) | |
| 265 | |
| 800 | 266 #ifdef ERROR_CHECK_TYPES |
| 826 | 267 DECLARE_INLINE_HEADER ( |
| 268 struct lstream * | |
| 428 | 269 error_check_lstream_type (struct lstream *stream, |
| 442 | 270 const Lstream_implementation *imp) |
| 826 | 271 ) |
| 428 | 272 { |
| 273 assert (stream->imp == imp); | |
| 274 return stream; | |
| 275 } | |
| 771 | 276 # define LSTREAM_TYPE_DATA(lstr, type) \ |
| 277 ((struct type##_stream *) \ | |
| 278 Lstream_data (error_check_lstream_type (lstr, lstream_##type))) | |
| 428 | 279 #else |
| 771 | 280 # define LSTREAM_TYPE_DATA(lstr, type) \ |
| 428 | 281 ((struct type##_stream *) Lstream_data (lstr)) |
| 282 #endif | |
| 283 | |
| 771 | 284 /* Declare that lstream-type TYPE has method M; used in initialization |
| 285 routines */ | |
| 428 | 286 #define LSTREAM_HAS_METHOD(type, m) \ |
| 287 (lstream_##type->m = type##_##m) | |
| 288 | |
| 289 | |
| 442 | 290 Lstream *Lstream_new (const Lstream_implementation *imp, |
| 291 const char *mode); | |
| 428 | 292 void Lstream_reopen (Lstream *lstr); |
| 293 void Lstream_set_buffering (Lstream *lstr, Lstream_buffering buffering, | |
| 294 int buffering_size); | |
| 295 int Lstream_flush (Lstream *lstr); | |
| 296 int Lstream_flush_out (Lstream *lstr); | |
| 297 int Lstream_fputc (Lstream *lstr, int c); | |
| 298 int Lstream_fgetc (Lstream *lstr); | |
| 299 void Lstream_fungetc (Lstream *lstr, int c); | |
| 665 | 300 Bytecount Lstream_read (Lstream *lstr, void *data, |
| 301 Bytecount size); | |
| 771 | 302 int Lstream_write (Lstream *lstr, const void *data, |
| 303 Bytecount size); | |
| 428 | 304 int Lstream_was_blocked_p (Lstream *lstr); |
| 665 | 305 void Lstream_unread (Lstream *lstr, const void *data, Bytecount size); |
| 428 | 306 int Lstream_rewind (Lstream *lstr); |
| 307 int Lstream_seekable_p (Lstream *lstr); | |
| 308 int Lstream_close (Lstream *lstr); | |
|
5588
2dbefd79b3d3
Prevent SIGPIPEs in deactivate_process().
Stephen J. Turnbull <stephen@xemacs.org>
parents:
5402
diff
changeset
|
309 int Lstream_close_noflush (Lstream *lstr); |
| 771 | 310 |
| 428 | 311 void Lstream_delete (Lstream *lstr); |
| 312 void Lstream_set_character_mode (Lstream *str); | |
| 771 | 313 void Lstream_unset_character_mode (Lstream *lstr); |
| 428 | 314 |
| 771 | 315 /* Lstream_putc: Write out one byte to the stream. This is a macro |
| 316 and so it is very efficient. The C argument is only evaluated once | |
| 317 but the STREAM argument is evaluated more than once. Returns 0 on | |
| 318 success, -1 on error. */ | |
| 428 | 319 |
| 771 | 320 #define Lstream_putc(stream, c) \ |
| 321 /* Call the function equivalent if the out buffer is full. Otherwise, \ | |
| 322 add to the end of the out buffer and, if line buffering is called for \ | |
| 323 and the character marks the end of a line, write out the buffer. */ \ | |
| 324 ((stream)->out_buffer_ind >= (stream)->out_buffer_size ? \ | |
| 325 Lstream_fputc (stream, c) : \ | |
| 326 ((stream)->out_buffer[(stream)->out_buffer_ind++] = \ | |
| 327 (unsigned char) (c), \ | |
| 328 (stream)->byte_count++, \ | |
| 329 (stream)->buffering == LSTREAM_LINE_BUFFERED && \ | |
| 330 (stream)->out_buffer[(stream)->out_buffer_ind - 1] == '\n' ? \ | |
| 428 | 331 Lstream_flush_out (stream) : 0)) |
| 332 | |
| 771 | 333 /* Lstream_getc: Read one byte from the stream and returns it as an |
| 334 unsigned char cast to an int, or EOF on end of file or error. This | |
| 335 is a macro and so it is very efficient. The STREAM argument is | |
| 336 evaluated more than once. */ | |
| 337 | |
| 338 #define Lstream_getc(stream) \ | |
| 339 /* Retrieve from unget buffer if there are any characters there; \ | |
| 340 else retrieve from in buffer if there's anything there; \ | |
| 341 else call the function equivalent */ \ | |
| 428 | 342 ((stream)->unget_buffer_ind > 0 ? \ |
| 343 ((stream)->byte_count++, \ | |
| 344 (stream)->unget_buffer[--(stream)->unget_buffer_ind]) : \ | |
| 345 (stream)->in_buffer_ind < (stream)->in_buffer_current ? \ | |
| 346 ((stream)->byte_count++, \ | |
| 347 (stream)->in_buffer[(stream)->in_buffer_ind++]) : \ | |
| 348 Lstream_fgetc (stream)) | |
| 349 | |
| 771 | 350 /* Lstream_ungetc: Push one byte back onto the input queue, cast to |
| 351 unsigned char. This will be the next byte read from the stream. | |
| 352 Any number of bytes can be pushed back and will be read in the | |
| 353 reverse order they were pushed back -- most recent first. (This is | |
| 354 necessary for consistency -- if there are a number of bytes that | |
| 355 have been unread and I read and unread a byte, it needs to be the | |
| 356 first to be read again.) This is a macro and so it is very | |
| 357 efficient. The C argument is only evaluated once but the STREAM | |
| 358 argument is evaluated more than once. | |
| 359 */ | |
| 360 | |
| 428 | 361 #define Lstream_ungetc(stream, c) \ |
| 771 | 362 /* Add to the end if it won't overflow buffer; otherwise call the \ |
| 363 function equivalent */ \ | |
| 428 | 364 ((stream)->unget_buffer_ind >= (stream)->unget_buffer_size ? \ |
| 365 Lstream_fungetc (stream, c) : \ | |
| 366 (void) ((stream)->byte_count--, \ | |
| 367 ((stream)->unget_buffer[(stream)->unget_buffer_ind++] = \ | |
| 368 (unsigned char) (c)))) | |
| 369 | |
| 370 #define Lstream_data(stream) ((void *) ((stream)->data)) | |
| 371 #define Lstream_byte_count(stream) ((stream)->byte_count) | |
| 372 | |
| 373 | |
| 374 /************************************************************************/ | |
| 867 | 375 /* working with an Lstream as a stream of Ichars */ |
| 428 | 376 /************************************************************************/ |
| 377 | |
| 378 #ifdef MULE | |
| 379 | |
| 826 | 380 DECLARE_INLINE_HEADER ( |
| 867 | 381 Ichar |
| 382 Lstream_get_ichar (Lstream *stream) | |
| 826 | 383 ) |
| 428 | 384 { |
| 385 int c = Lstream_getc (stream); | |
| 826 | 386 return (c < 0x80 /* c == EOF || byte_ascii_p (c) */ |
| 867 | 387 ? (Ichar) c |
| 388 : Lstream_get_ichar_1 (stream, c)); | |
| 428 | 389 } |
| 390 | |
| 867 | 391 /* Write an Ichar to a stream. Return value is 0 for success, -1 for |
| 771 | 392 failure. */ |
| 393 | |
| 826 | 394 DECLARE_INLINE_HEADER ( |
| 395 int | |
| 867 | 396 Lstream_put_ichar (Lstream *stream, Ichar ch) |
| 826 | 397 ) |
| 428 | 398 { |
| 867 | 399 return ichar_ascii_p (ch) ? |
| 428 | 400 Lstream_putc (stream, ch) : |
| 867 | 401 Lstream_fput_ichar (stream, ch); |
| 428 | 402 } |
| 403 | |
| 826 | 404 DECLARE_INLINE_HEADER ( |
| 405 void | |
| 867 | 406 Lstream_unget_ichar (Lstream *stream, Ichar ch) |
| 826 | 407 ) |
| 428 | 408 { |
| 867 | 409 if (ichar_ascii_p (ch)) |
| 428 | 410 Lstream_ungetc (stream, ch); |
| 411 else | |
| 867 | 412 Lstream_funget_ichar (stream, ch); |
| 428 | 413 } |
| 414 #else /* not MULE */ | |
| 415 | |
| 867 | 416 # define Lstream_get_ichar(stream) Lstream_getc (stream) |
| 417 # define Lstream_put_ichar(stream, ch) Lstream_putc (stream, ch) | |
| 418 # define Lstream_unget_ichar(stream, ch) Lstream_ungetc (stream, ch) | |
| 428 | 419 |
| 420 #endif /* not MULE */ | |
| 421 | |
| 422 | |
| 423 /************************************************************************/ | |
| 424 /* Lstream implementations */ | |
| 425 /************************************************************************/ | |
| 426 | |
| 427 /* Flags we can pass to the filedesc and stdio streams. */ | |
| 428 | |
| 429 /* If set, close the descriptor or FILE * when the stream is closed. */ | |
| 430 #define LSTR_CLOSING 1 | |
| 431 | |
| 432 /* If set, allow quitting out of the actual I/O. */ | |
| 433 #define LSTR_ALLOW_QUIT 2 | |
| 434 | |
| 435 /* If set and filedesc_stream_set_pty_flushing() has been called | |
| 436 on the stream, do not send more than pty_max_bytes on a single | |
| 437 line without flushing the data out using the eof_char. */ | |
| 438 #define LSTR_PTY_FLUSHING 4 | |
| 439 | |
| 440 /* If set, an EWOULDBLOCK error is not treated as an error but | |
| 441 simply causes the write function to return 0 as the number | |
| 442 of bytes written out. */ | |
| 443 #define LSTR_BLOCKED_OK 8 | |
| 444 | |
| 445 Lisp_Object make_stdio_input_stream (FILE *stream, int flags); | |
| 446 Lisp_Object make_stdio_output_stream (FILE *stream, int flags); | |
| 447 Lisp_Object make_filedesc_input_stream (int filedesc, int offset, int count, | |
| 448 int flags); | |
| 449 Lisp_Object make_filedesc_output_stream (int filedesc, int offset, int count, | |
| 450 int flags); | |
| 451 void filedesc_stream_set_pty_flushing (Lstream *stream, | |
| 452 int pty_max_bytes, | |
| 867 | 453 Ibyte eof_char); |
| 428 | 454 int filedesc_stream_fd (Lstream *stream); |
| 455 Lisp_Object make_lisp_string_input_stream (Lisp_Object string, | |
| 456 Bytecount offset, | |
| 457 Bytecount len); | |
| 462 | 458 Lisp_Object make_fixed_buffer_input_stream (const void *buf, |
| 665 | 459 Bytecount size); |
| 462 | 460 Lisp_Object make_fixed_buffer_output_stream (void *buf, |
| 665 | 461 Bytecount size); |
| 442 | 462 const unsigned char *fixed_buffer_input_stream_ptr (Lstream *stream); |
| 428 | 463 unsigned char *fixed_buffer_output_stream_ptr (Lstream *stream); |
| 464 Lisp_Object make_resizing_buffer_output_stream (void); | |
| 465 unsigned char *resizing_buffer_stream_ptr (Lstream *stream); | |
| 788 | 466 Lisp_Object resizing_buffer_to_lisp_string (Lstream *stream); |
| 428 | 467 Lisp_Object make_dynarr_output_stream (unsigned_char_dynarr *dyn); |
| 468 #define LSTR_SELECTIVE 1 | |
| 469 #define LSTR_IGNORE_ACCESSIBLE 2 | |
| 665 | 470 Lisp_Object make_lisp_buffer_input_stream (struct buffer *buf, Charbpos start, |
| 471 Charbpos end, int flags); | |
| 472 Lisp_Object make_lisp_buffer_output_stream (struct buffer *buf, Charbpos pos, | |
| 428 | 473 int flags); |
| 665 | 474 Charbpos lisp_buffer_stream_startpos (Lstream *stream); |
| 428 | 475 |
| 440 | 476 #endif /* INCLUDED_lstream_h_ */ |