"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

ReadWriteStream subclass:#ExternalStream

	instanceVariableNames:'filePointer mode buffered binary eolMode hitEOF didWrite

		lastErrorNumber readAhead'

	classVariableNames:'Lobby LastErrorNumber InvalidReadSignal InvalidWriteSignal

		InvalidModeSignal OpenErrorSignal StreamNotOpenSignal

		InvalidOperationSignal DefaultEOLMode ReadMode ReadWriteMode

		WriteMode AppendMode CreateReadWriteMode StreamIOErrorSignal'

	poolDictionaries:''

	category:'Streams-External'

!

!ExternalStream primitiveDefinitions!

%{

#ifdef __openVMS__                                        

# undef __new    

#endif

#include <stdio.h>

#define _STDIO_H_INCLUDED_

#ifndef NO_FCNTL_H

# include <fcntl.h>

# define _FCNTL_H_INCLUDED_

#endif

#include <errno.h>

#define _ERRNO_H_INCLUDED_

#ifdef LINUX

  /* use inline string macros */

# define __STRINGDEFS__

# include <linuxIntern.h>

#endif

#ifdef hpux

# define fileno(f)      ((f->__fileH << 8) | (f->__fileL))

#endif

#ifndef SEEK_SET

# define SEEK_SET 0

#endif

#ifndef SEEK_CUR

# define SEEK_CUR 1

#endif

#ifndef SEEK_END

# define SEEK_END 2

#endif

#ifdef __VMS__

# define CLEAR_ERRNO            errno = 0;

#else

# define CLEAR_ERRNO            /* nothing */

#endif

#ifdef LATER

#define __isFilePointer(x)      (__Class(x) == ExternalStream__FilePointer)

#define __CHANGECLASS(o, x)     (__qClass(o) = (x), o)

#define __MKFILEPOINTER(f)      __CHANGECLASS(__MKEXTERNALADDRESS(f), ExternalStream__FilePointer)

#else

#define __MKFILEPOINTER(f)      __MKEXTERNALADDRESS(f)

#endif

#ifdef xxxWIN32

# define NO_STDIO

# define __HANDLEVal(o)         (HFILE)(__externalAddressVal(o))

# define READ(f, cp, n)         _lread((f), (cp), (n))

# define WRITE(f, cp, n)        _lwrite((f), (cp), (n))

# define FFLUSH(fp)             /* nothing */

# undef STDIO_NEEDS_FSEEK

# define FILEPOINTER            HFILE

# define FILENO(f)              (f)

#else

# define STDIO_NEEDS_FSEEK

# define FILEPOINTER            FILE *

# define READ(f, cp, n)         read(f, cp, n)

# define WRITE(f, cp, n)        write(f, cp, n)

# define FFLUSH(fp)             fflush(fp)

# define FILENO(f)              fileno(f)

#endif

#if defined(WIN32) && defined(NO_STDIO)

# ifdef i386

#  define _X86_

# endif

# undef INT

# undef Array

# undef Number

# undef Method

# undef Point

# undef Rectangle

# undef Block

/* # include <windows.h> /* */

# include <stdarg.h> /* */

# include <windef.h> /* */

# include <winbase.h> /* */

# include <wingdi.h> /* */

# include <winuser.h> /* */

# ifdef __DEF_Array

#   define Array __DEF_Array

# endif

# ifdef __DEF_Number

#   define Number __DEF_Number

# endif

# ifdef __DEF_Method

#   define Method __DEF_Method

# endif

# ifdef __DEF_Point

#   define Point __DEF_Point

# endif

# ifdef __DEF_Block

#   define Block __DEF_Block

# endif

# define stat _stat

#endif /* WIN32 */

/*

 * stdio library requires an fseek before reading whenever a file

 * is open for read/write and the last operation was a write.

 * (also vice-versa).

 * All code should use the following macro before doing reads:

 */

#ifdef STDIO_NEEDS_FSEEK

# define OPT_FSEEK(f, pos, whence)      fseek(f, pos, whence)

#else

# define OPT_FSEEK(f, pos, whence)      /* nothing */

#endif

#define __READING__(f)                          \

    if ((__INST(didWrite) != false)              \

     && (__INST(mode) == @symbol(readwrite))) {  \

	__INST(didWrite) = false;                \

	OPT_FSEEK(f, 0L, SEEK_CUR); /* needed in stdio */  \

    }

#define __WRITING__(f)                          \

    if ((__INST(didWrite) != true)               \

     && (__INST(mode) == @symbol(readwrite))) {  \

	__INST(didWrite) = true;                 \

	OPT_FSEEK(f, 0L, SEEK_CUR); /* needed in stdio */  \

    }

#ifdef NO_STDIO

#define __UNGETC__(c, f, isBuffered)                    \

    __INST(readAhead) = __MKSMALLINT((c));

#else

#define __UNGETC__(c, f, isBuffered)                    \

    if (isBuffered) {                                   \

	ungetc((c), (f));                               \

    } else {                                            \

	__INST(readAhead) = __MKSMALLINT((c));          \

    }

#endif

#ifdef NO_STDIO

#define __READBYTE__(ret, f, buf, isBuffered)           \

    {                                                   \

	OBJ rA = __INST(readAhead);                     \

	if (rA != nil) {                                \

	    *(buf) = __intVal(rA);                      \

	    __INST(readAhead) = nil;                    \

	    (ret) = 1;                                  \

	} else {                                        \

	    for (;;) {                                  \

		CLEAR_ERRNO;                            \

		(ret) = READ(f, buf, 1);                \

		if ((ret) >= 0 || errno != EINTR)       \

		    break;                              \

		__HANDLE_INTERRUPTS__;                  \

	    }                                           \

	}                                               \

    }

#else

#define __READBYTE__(ret, f, buf, isBuffered)           \

    if (isBuffered) {                                   \

	for (;;) {                                      \

	    CLEAR_ERRNO;                                \

	    (ret) = getc(f);                            \

	    if ((ret) >= 0) {                           \

		*(buf) = (ret);                         \

		(ret) = 1;                              \

	    } else if (ferror(f)) {                     \

		if (errno == EINTR) {                   \

		    __HANDLE_INTERRUPTS__;              \

		    clearerr(f);                        \

		    continue;                           \

		}                                       \

	    } else                                      \

		(ret) = 0;                              \

	    break;                                      \

	}                                               \

    } else {                                            \

	OBJ rA = __INST(readAhead);                     \

	if (rA != nil) {                                \

	    *(buf) = __intVal(rA);                      \

	    __INST(readAhead) = nil;                    \

	    (ret) = 1;                                  \

	} else {                                        \

	    for (;;) {                                  \

		CLEAR_ERRNO;                            \

		(ret) = read(fileno(f), buf, 1);        \

		if ((ret) >= 0 || errno != EINTR)       \

		    break;                              \

		__HANDLE_INTERRUPTS__;                  \

	    }                                           \

	}                                               \

   }                                                                          

#endif

/*

 * read_bytes into a c-buffer

 * (which may NOT move)

 */

#ifdef NO_STDIO

#define __READBYTES__(ret, f, buf, cnt, isBuffered)     \

    {                                                   \

	int __offs = 0;                                 \

							\

	while (__offs < (cnt)) {                        \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

		(buf)[__offs] = __intVal(rA);           \

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

	    } else {                                    \

		CLEAR_ERRNO;                            \

		(ret) = READ(f, (buf)+__offs, (cnt)-__offs); \

		if ((ret) <= 0) {                       \

		    if ((ret) < 0 && errno == EINTR) {  \

			__HANDLE_INTERRUPTS__;          \

			continue;                       \

		    }                                   \

		    break;                              \

		}                                       \

	    }                                           \

	    __offs += (ret);                            \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

   }

#else

#define __READBYTES__(ret, f, buf, cnt, isBuffered)     \

    (ret) = 0;                                          \

    if (isBuffered) {                                   \

	int __offs = 0;                                 \

	while (__offs < (cnt)) {                        \

	    CLEAR_ERRNO;                                \

	    (ret) = getc(f);                            \

	    if ((ret) < 0) {                            \

		if (ferror(f)) {                        \

		    if (errno == EINTR) {               \

			__HANDLE_INTERRUPTS__;          \

			clearerr(f);                    \

			continue;                       \

		    }                                   \

		} else {                                \

		    (ret) = 0;                          \

		}                                       \

		break;                                  \

	    }                                           \

	    (buf)[__offs++] = (ret);                    \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    } else {                                            \

	int __offs = 0;                                 \

	int fd = fileno(f);                             \

							\

	while (__offs < (cnt)) {                        \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

		(buf)[__offs] = __intVal(rA);           \

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

	    } else {                                    \

		CLEAR_ERRNO;                            \

		(ret) = read(fd, (buf)+__offs, (cnt)-__offs);                 \

		if ((ret) <= 0) {                       \

		    if ((ret) < 0 && errno == EINTR) {  \

			__HANDLE_INTERRUPTS__;          \

			continue;                       \

		    }                                   \

		    break;                              \

		}                                       \

	    }                                           \

	    __offs += (ret);                            \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

   }

#if defined(F_GETFL) && defined(F_SETFL) && defined(FNDELAY)

# define GETFLAGS(fd) \

        fcntl(fd, F_GETFL, 0);

# define SETFLAGS(fd, flags) \

	fcntl(fd, F_SETFL, flags)

# define SETNONBLOCKING(fd) \

	{ \

	    int flags; \

	    flags = fcntl(fd, F_GETFL, 0); \

	    if (flags >= 0) { \

		fcntl(fd, F_SETFL, flags | FNDELAY); \

	    } \

	}

#else

# define GETFLAGS(fd) 0

# define SETFLAGS(fd, flags) /* nothing */

# define SETNONBLOCKING(fd) /* nothing */

#endif                                                        

#define __READAVAILBYTES__(ret, f, buf, cnt, isBuffered) \

  {                                                     \

    int __offs = 0;                                     \

    int oldFlags;					\

							\

    (ret) = 0;                                          \

    oldFlags = GETFLAGS(fileno(f));			\

    SETNONBLOCKING(fileno(f));				\

    if (isBuffered) {                                   \

	while (__offs < (cnt)) {                        \

	    CLEAR_ERRNO;                                \

	    (ret) = getc(f);                            \

	    if ((ret) < 0) {                            \

		if (ferror(f)) {                        \

		    if (errno == EINTR) {               \

			__HANDLE_INTERRUPTS__;          \

			clearerr(f);                    \

			continue;                       \

		    }                                   \

		} else {                                \

		    (ret) = 0;                          \

		}                                       \

		break;                                  \

	    }                                           \

	    (buf)[__offs++] = (ret);                    \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    } else {                                            \

	int fd = fileno(f);                             \

							\

	while (__offs < (cnt)) {                        \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

		(buf)[__offs] = __intVal(rA);           \

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

		__offs += (ret);                        \

		continue;                               \

	    }                                           \

	    CLEAR_ERRNO;                                \

	    (ret) = read(fd, (buf)+__offs, (cnt)-__offs); \

	    if ((ret) < 0) {          			\

	        if (errno == EINTR) {                   \

		    __HANDLE_INTERRUPTS__;              \

		    continue;                           \

		}					\

		break;					\

	    }                                           \

	    __offs += (ret);                            \

	    break;                                      \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    }                                                   \

    SETFLAGS(fileno(f), oldFlags);			\

  }

#endif

/*

 * read_bytes into an object

 * (which may be moved by GC)

 */

#ifdef NO_STDIO

#define __READBYTES_OBJ__(ret, f, obj, obj_offs, cnt, isBuffered)     \

  {                                                     \

    int __ooffs = obj_offs;                             \

    int __offs = 0;                                     \

    char *buf = (char *)(obj);                          \

							\

    (ret) = 0;                                          \

    {                                                   \

	while (__offs < (cnt)) {                        \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

		(buf)[__ooffs+__offs] = __intVal(rA);   \

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

	    } else {                                    \

		CLEAR_ERRNO;                            \

		(ret) = READ(f, (buf)+__ooffs+__offs, (cnt)-__offs); \

		if ((ret) <= 0) {                       \

		    if ((ret) < 0 && errno == EINTR) {  \

			__HANDLE_INTERRUPTS__;          \

			/* refetch */                   \

			buf = (char *)(obj);            \

			continue;                       \

		    }                                   \

		    break;                              \

		}                                       \

	    }                                           \

	    __offs += (ret);                            \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    }                                                   \

  }

#else

#define __READBYTES_OBJ__(ret, f, obj, obj_offs, cnt, isBuffered)     \

  {                                                     \

    int __ooffs = obj_offs;                             \

    int __offs = 0;                                     \

    char *buf = (char *)(obj);                          \

							\

    (ret) = 0;                                          \

    if (isBuffered) {                                   \

	while (__offs < (cnt)) {                        \

	    CLEAR_ERRNO;                                \

	    (ret) = getc(f);                            \

	    if ((ret) < 0) {                            \

		if (ferror(f)) {                        \

		    if (errno == EINTR) {               \

			__HANDLE_INTERRUPTS__;          \

			clearerr(f);                    \

			/* refetch */                   \

			buf = (char *)(obj);            \

			continue;                       \

		    }                                   \

		} else {                                \

		    (ret) = 0;                          \

		}                                       \

		break;                                  \

	    }                                           \

	    (buf)[__ooffs+__offs] = (ret);              \

	    __offs++;                                   \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    } else {                                            \

	int fd = fileno(f);                             \

							\

	while (__offs < (cnt)) {                        \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

		(buf)[__ooffs+__offs] = __intVal(rA);   \

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

	    } else {                                    \

		CLEAR_ERRNO;                            \

		(ret) = read(fd, (buf)+__ooffs+__offs, (cnt)-__offs); \

		if ((ret) <= 0) {                       \

		    if ((ret) < 0 && errno == EINTR) {  \

			__HANDLE_INTERRUPTS__;          \

			/* refetch */                   \

			buf = (char *)(obj);            \

			continue;                       \

		    }                                   \

		    break;                              \

		}                                       \

	    }                                           \

	    __offs += (ret);                            \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    }                                                   \

  }