xemacs-beta: src/lstream.h comparison

comparison src/lstream.h @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14

author	cvs
date	Mon, 13 Aug 2007 11:20:41 +0200
parents	2f8bb876ab1d
children	11054d720c21

comparison

equal deleted inserted replaced

-:12e008d41344
+:697ef44129c6
 /* Synched up with: Not in FSF. */
 /* Written by Ben Wing. */
-#ifndef INCLUDED_lstream_h_
+#ifndef _XEMACS_LSTREAM_H_
-#define INCLUDED_lstream_h_
+#define _XEMACS_LSTREAM_H_
 /************************************************************************/
 /*                     definition of Lstream object                     */
 /************************************************************************/
 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;
+CONST char *name;
 size_t 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
 This function can be NULL if the stream is output-only. */
 /* The omniscient mly, blinded by the irresistable thrall of Common
 Lisp, thinks that it is bogus that the types and implementations
 of input and output streams are the same. */
-ssize_t (*reader) (Lstream *stream, unsigned char *data, size_t size);
+int (*reader) (Lstream *stream, unsigned char *data, size_t 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. */
-ssize_t (*writer) (Lstream *stream, const unsigned char *data, size_t size);
+int (*writer) (Lstream *stream, CONST unsigned char *data, size_t 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. */
 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);
+Lisp_Object (*marker) (Lisp_Object lstream, void (*markfun) (Lisp_Object));
 } Lstream_implementation;
 #define DEFINE_LSTREAM_IMPLEMENTATION(name,c_name,size)	\
 Lstream_implementation c_name[1] =			\
 { { (name), (size) } }
 #define LSTREAM_FL_CLOSE_AT_DISKSAVE	16
 struct lstream
 {
 struct lcrecord_header header;
-const Lstream_implementation *imp; /* methods for this stream */
+CONST Lstream_implementation *imp; /* methods for this stream */
 Lstream_buffering buffering; /* type of buffering in use */
 size_t buffering_size; /* number of bytes buffered */
 unsigned char *in_buffer; /* holds characters read from stream end */
 size_t in_buffer_size; /* allocated size of buffer */
 #define LSTREAM_TYPE_P(lstr, type) \
 ((lstr)->imp == lstream_##type)
 #ifdef ERROR_CHECK_TYPECHECK
-INLINE_HEADER struct lstream *
+INLINE struct lstream *
 error_check_lstream_type (struct lstream *stream,
-			  const Lstream_implementation *imp);
+			  CONST Lstream_implementation *imp);
-INLINE_HEADER struct lstream *
+INLINE struct lstream *
 error_check_lstream_type (struct lstream *stream,
-			  const Lstream_implementation *imp)
+			  CONST Lstream_implementation *imp)
 {
 assert (stream->imp == imp);
 return stream;
 }
 # define LSTREAM_TYPE_DATA(lstr, type) \
 initialization routines */
 #define LSTREAM_HAS_METHOD(type, m) \
 (lstream_##type->m = type##_##m)
-Lstream *Lstream_new (const Lstream_implementation *imp,
+Lstream *Lstream_new (CONST Lstream_implementation *imp,
-		      const char *mode);
+		      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);
-ssize_t Lstream_read (Lstream *lstr, void *data, size_t size);
+int Lstream_read (Lstream *lstr, void *data, size_t size);
-ssize_t Lstream_write (Lstream *lstr, const void *data, size_t size);
+int Lstream_write (Lstream *lstr, CONST void *data, size_t size);
 int Lstream_was_blocked_p (Lstream *lstr);
-void Lstream_unread (Lstream *lstr, const void *data, size_t size);
+void Lstream_unread (Lstream *lstr, CONST void *data, size_t 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);
 #ifndef BYTE_ASCII_P
 #include "mule-charset.h"
 #endif
-INLINE_HEADER Emchar Lstream_get_emchar (Lstream *stream);
+INLINE Emchar Lstream_get_emchar (Lstream *stream);
-INLINE_HEADER Emchar
+INLINE Emchar
 Lstream_get_emchar (Lstream *stream)
 {
 int c = Lstream_getc (stream);
 return BYTE_ASCII_P (c) ? (Emchar) c :
 Lstream_get_emchar_1 (stream, c);
 }
-INLINE_HEADER int Lstream_put_emchar (Lstream *stream, Emchar ch);
+INLINE int Lstream_put_emchar (Lstream *stream, Emchar ch);
-INLINE_HEADER int
+INLINE 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 void Lstream_unget_emchar (Lstream *stream, Emchar ch);
-INLINE_HEADER void
+INLINE void
 Lstream_unget_emchar (Lstream *stream, Emchar ch)
 {
 if (CHAR_ASCII_P (ch))
 Lstream_ungetc (stream, ch);
 else
 				       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, size_t size);
+Lisp_Object make_fixed_buffer_input_stream (CONST unsigned char *buf,
-Lisp_Object make_fixed_buffer_output_stream (void *buf, size_t size);
+					    size_t size);
-const unsigned char *fixed_buffer_input_stream_ptr (Lstream *stream);
+Lisp_Object make_fixed_buffer_output_stream (unsigned char *buf,
+					     size_t 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
 					   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_ */
+#endif /* _XEMACS_LSTREAM_H_ */

Mercurial > hg > xemacs-beta

comparison src/lstream.h @ 412:697ef44129c6 r21-2-14