"

 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.

"

"{ Package: 'stx:libbasic' }"

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

		FileOpenTrace'

	poolDictionaries:''

	category:'Streams-External'

!

!ExternalStream primitiveDefinitions!

%{

#undef fwrite

#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

#if defined(__VMS__) || defined(__sparc__) || defined(WIN32)

# define CLEAR_ERRNO            __threadErrno = 0;

#else

# define CLEAR_ERRNO            /* nothing */

#endif

#ifdef LATER

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

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

#else

#endif

#ifdef WIN32

# define NO_STDIO

# undef __HANDLE_INTERRUPTS__

# define __HANDLE_INTERRUPTS__    /* nothing */

# undef __BEGIN_INTERRUPTABLE__

# define __BEGIN_INTERRUPTABLE__  /* nothing */

# undef __END_INTERRUPTABLE__

# define __END_INTERRUPTABLE__    /* nothing */

#endif

# ifdef __i386__

#  define _X86_

# endif

#ifdef WIN32

# undef INT

# undef Array

# undef Number

# undef Method

# undef Point

# undef Rectangle

# undef Block

# undef Time

# undef Date

# undef Delay

# undef Set

# undef Signal

# undef Context

# undef Message

# undef Process

# undef Processor

# define NOATOM

# define NOGDICAPMASKS

# define NOMETAFILE

# define NOMINMAX

//#d efine NOOPENFILE

# define NOSOUND

# define NOWH

//# define NOCOMM

# define NOKANJI

# define NOCRYPT

//# define NOMCX

# define WIN32_LEAN_AND_MEAN

# include <windows.h>

# include <winsock.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

# ifdef __DEF_Time

#  define Time __DEF_Time

# endif

# ifdef __DEF_Date

#  define Date __DEF_Date

# endif

# ifdef __DEF_Set

#  define Set __DEF_Set

# endif

# ifdef __DEF_Signal

#  define Signal __DEF_Signal

# endif

# ifdef __DEF_Delay

#  define Delay __DEF_Delay

# endif

# ifdef __DEF_Context

#  define Context __DEF_Context

# endif

# ifdef __DEF_Message

#  define Message __DEF_Message

# endif

# ifdef __DEF_Process

#  define Process __DEF_Process

# endif

# ifdef __DEF_Processor

#  define Processor __DEF_Processor

# endif

# define INT    int

# define UINT   uint

# define off_t  long

#endif /* WIN32 */

#ifndef NO_STDIO /* use STDIO */

# 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 /* use STDIO */

#ifdef DEBUGGING

  extern char *__survStartPtr, *__survEndPtr;

# define DEBUGBUFFER(buf)  \

    if (((char *)(buf) >= __survStartPtr) \

     && ((char *)(buf) < __survEndPtr)) { \

	__fatal0("read into survivor\n"); \

    }

#else

# define DEBUGBUFFER(buf) /* nothing */

#endif

/*

 * 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

#ifdef WIN32

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

int _rtl_read();

int _rtl_write();

int _rtl_read();

int _rtl_write();

# ifdef __BORLANDC__

#  define READ(ret,f, cp, n) \

      { int __res;\

	HANDLE h; \

	h = _get_osfhandle(fileno(f)); \

	if (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0) \

	  (ret) = __STX_WSA_NOINT_CALL4("recv", recv, h, (cp), (n), 0);\

	else \

	  (ret) = __STX_C_NOINT_CALL3("_rtl_read", _rtl_read, fileno(f), (cp), (n));\

      }

#  define WRITE(ret,f, cp, n) \

      { int __res;\

	HANDLE h; \

	h = _get_osfhandle(fileno(f)); \

	if (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0) \

	  (ret) = __STX_WSA_NOINT_CALL4("send", send, h, (cp), (n), 0);\

	else \

	  (ret) = __STX_C_NOINT_CALL3("_rtl_write", _rtl_write, fileno(f), (cp), (n));\

      }

# else /* MSC */

#  define READ(ret,f, cp, n) \

      { int __res;\

	HANDLE h; \

	h = _get_osfhandle(fileno(f)); \

	if (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0) \

	  (ret) = __STX_WSA_NOINT_CALL4("recv", recv, h, (cp), (n), 0);\

	else { \

	  (ret) = __STX_API_NOINT_CALL5("ReadFile", ReadFile, h, (cp), (n), &__res, 0);\

	  if (ret) \

	    ret = __res; \

	} \

      }

#  define WRITE(ret,f, cp, n) \

      { int __res;\

	HANDLE h; \

	h = _get_osfhandle(fileno(f)); \

	if (ioctlsocket((SOCKET)h,FIONREAD,&__res)==0) \

	  (ret) = __STX_WSA_NOINT_CALL4("send", send, h, (cp), (n), 0);\

	else {\

	  (ret) = __STX_API_NOINT_CALL5("WriteFile", WriteFile, h, (cp), (n), &__res, 0);\

	  if (ret) \

	    ret = __res; \

	} \

      }

# endif /* MSC */

# define FFLUSH(fp)             fflush(fp)

# undef STDIO_NEEDS_FSEEK

# define FILEPOINTER            FILE *

# define FILENO(f)              fileno(f)

# 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 */  \

    }

# define __UNGETC__(c, f, isBuffered)                   \

    if (isBuffered) {                                   \

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

    } else {                                            \

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

    }

# 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 (__threadErrno == EINTR) {           \

		    clearerr(f);                        \

		    continue;                           \

		}                                       \

	    } else {                                    \

		(ret) = 0;                              \

	    }                                           \

	    break;                                      \

	}                                               \

    } else {                                            \

	OBJ rA = __INST(readAhead);                     \

	if (rA != nil) {                                \

	    *(buf) = (char)__intVal(rA);                \

	    __INST(readAhead) = nil;                    \

	    (ret) = 1;                                  \

	} else {                                        \

	    for (;;) {                                  \

		CLEAR_ERRNO;                            \

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

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

		    break;                              \

	    }                                           \

	}                                               \

    }

  /*

   * read_bytes into a c-buffer

   * (which may NOT move)

   */

# 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 (__threadErrno == EINTR) {               \

			clearerr(f);                    \

			continue;                       \

		    }                                   \

		} else {                                \

		    (ret) = 0;                          \

		}                                       \

		break;                                  \

	    }                                           \

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

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    } else {                                            \

	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;                            \

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

		if ((ret) <= 0) {                       \

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

			continue;                       \

		    }                                   \

		    break;                              \

		}                                       \

	    }                                           \

	    __offs += (ret);                            \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

   }

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

  {                                                     \

    int __offs = 0;                                     \

    int oldFlags;                                       \

							\

    (ret) = 0;                                          \

    if (isBuffered) {                                   \

	while (__offs < (cnt)) {                        \

	    CLEAR_ERRNO;                                \

	    (ret) = getc(f);                            \

	    if ((ret) < 0) {                            \

		if (ferror(f)) {                        \

		    if (__threadErrno == EINTR) {               \

			clearerr(f);                    \

			continue;                       \

		    }                                   \

		} else {                                \

		    (ret) = 0;                          \

		}                                       \

		break;                                  \

	    }                                           \

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

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    } else {                                            \

	while (__offs < (cnt)) {                        \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

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

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

		__offs += (ret);                        \

		continue;                               \

	    }                                           \

	    CLEAR_ERRNO;                                \

	    {                                           \

	      int res;                                  \

	      if (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res)==0) { \

		  if (res > 0) {                        \

		      if (res > ((cnt)-__offs))         \

			res = (cnt)-__offs;             \

		      READ(ret,f, (buf)+__offs, res);   \

		  } else {                              \

		      (ret) = 0;                        \

		  }                                     \

	      } else if (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0)) { \

		  if (res > 0) {                        \

		      if (res > ((cnt)-__offs))         \

			res = (cnt)-__offs;             \

		      READ(ret,f, (buf)+__offs, res);   \

		  } else                                \

		      ret = 0;                          \

	      } else {                                  \

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

	      }                                         \

	    }                                           \

	    if ((ret) < 0) {                            \

		if (__threadErrno == EINTR) {                   \

		    continue;                           \

		}                                       \

		break;                                  \

	    }                                           \

	    __offs += (ret);                            \

	    break;                                      \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    }                                                   \

  }

# define IO_BUFFER_SIZE        (8*1024)

# 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 (__threadErrno == EINTR) {               \

			clearerr(f);                    \

			/* refetch */                   \

			buf = (char *)(obj);            \

			continue;                       \

		    }                                   \

		} else {                                \

		    (ret) = 0;                          \

		}                                       \

		break;                                  \

	    }                                           \

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

	    __offs++;                                   \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

    } else {                                            \

	while (__offs < (cnt)) {                        \

	    char __buf[IO_BUFFER_SIZE];                 \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

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

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

	    } else {                                    \

		int l;                                  \

		CLEAR_ERRNO;                            \

		l = (cnt)-__offs;                       \

		if ( l > IO_BUFFER_SIZE)                \