"

 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' }"

"{ NameSpace: Smalltalk }"

ReadWriteStream subclass:#ExternalStream

	instanceVariableNames:'handleType handle 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 MaxNonTenurableExecutors'

	poolDictionaries:''

	category:'Streams-External'

!

!ExternalStream primitiveDefinitions!

%{

#undef fwrite

#include "stxOSDefs.h"

#include <stdio.h>

#define _STDIO_H_INCLUDED_

#include <stdlib.h>

#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

#ifndef WIN32

# include <sys/ioctl.h>

# include <unistd.h>

#endif

#if !defined(MSDOS_LIKE) && !defined(__openVMS__)

# include <termios.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)

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

#else

# define __MKFILEPOINTER(f)      __MKEXTERNALADDRESS(f)

#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 UINT

# 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

# undef String

# undef Character

# define NOATOM

# define NOGDICAPMASKS

# define NOMETAFILE

# define NOMINMAX

//# define NOOPENFILE

# define NOSOUND

# define NOWH

//# define NOCOMM

# define NOKANJI

# define NOCRYPT

//# define NOMCX

# define WIN32_LEAN_AND_MEAN

# include <windows.h>

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

# ifdef __DEF_String

#  define String __DEF_String

# endif

# ifdef __DEF_Character

#  define Character __DEF_Character

# endif

# define INT    STX_INT

# define UINT   STX_UINT

# ifndef off_t

#  define off_t  long

# endif

#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__

// Win returns from ReadFile() with false and _threadErrno == 0 on end of pipe.

// We don't know why

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

	if (handleType == @symbol(socketHandle)) { \

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

	} else { \

	  HANDLE h = _get_osfhandle(fileno(f)); \

	  if (handleType == @symbol(socketFilePointer)) { \

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

	  } else { \

	    int __res; \

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

	    (ret) = (ret) ? __res : ((__threadErrno == EPIPE || __threadErrno == 0) ? 0 : -1); \

	  } \

	} \

      }

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

	if (handleType == @symbol(socketHandle)) { \

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

	} else {\

	  HANDLE h = _get_osfhandle(fileno(f)); \

	  if (handleType == @symbol(socketFilePointer)) { \

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

	  } else {\

	    int __res; \

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

	    (ret) = (ret) ? __res : -1; \

	  } \

	} \

      }

# 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, handleType) \

    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, handleType);       \

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

		    break;                              \

	    }                                           \

	}                                               \

    }

  /*

   * read_bytes into a c-buffer

   * (which may NOT move)

   */

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

    (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, handleType); \

		if ((ret) <= 0) {                       \

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

			continue;                       \

		    }                                   \

		    break;                              \

		}                                       \

	    }                                           \

	    __offs += (ret);                            \

	}                                               \

	if (__offs > 0)                                 \

	    (ret) = __offs;                             \

   }

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

  {                                                     \

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

	}                                               \

	(ret) = __offs;                                 \

    } else {                                            \

	while (__offs < (cnt)) {                        \

	    OBJ rA = __INST(readAhead);                 \

	    if (rA != nil) {                            \

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

		__INST(readAhead) = nil;                \

		(ret) = 1;                              \

		__offs ++;                              \

		continue;                               \

	    }                                           \

	    CLEAR_ERRNO;                                \

	    {                                           \

	      int res = 0;                              \

	      if ((handleType == @symbol(socketFilePointer) && (ioctlsocket((SOCKET)_get_osfhandle(fileno(f)),FIONREAD,&res), 1)) \

		  || (handleType == @symbol(socketHandle) && (ioctlsocket((SOCKET)(f), FIONREAD, &res), 1)) \

		  || (handleType == @symbol(pipeFilePointer) && (PeekNamedPipe((HANDLE)_get_osfhandle(fileno(f)),0, 0,0,&res,0), 1))) { \

		  if (res > 0) {                        \

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

			  res = (cnt)-__offs;           \

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

		  } else {                              \

		      (ret) = 0;                        \

		      break;                            \

		  }                                     \

	      } else {                                  \

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

	      }                                         \

	    }                                           \

	    if ((ret) <= 0) {                           \

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

		    continue;                           \

		break;                                  \

	    }                                           \

	    __offs += (ret);                            \

	}                                               \

	(ret) = __offs;                                 \

    }                                                   \

  }

# define IO_BUFFER_SIZE        (8*1024)

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

  {                                                     \

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

		  l = IO_BUFFER_SIZE;                   \

		READ((ret),f, __buf, l, handleType);                  \

		if ((ret) <= 0) {                       \

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

			continue;                       \