"

 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!

%{

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

# 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

#endif

#ifdef NO_STDIO

# undef __HANDLE_INTERRUPTS__

# define __HANDLE_INTERRUPTS__    /* nothing */

# undef __BEGIN_INTERRUPTABLE__

# define __BEGIN_INTERRUPTABLE__  /* nothing */

# undef __END_INTERRUPTABLE__

# define __END_INTERRUPTABLE__    /* nothing */

# ifdef i386

#  define _X86_

# endif

# undef INT

# undef Array

# undef Number

# undef Method

# undef Point

# undef Rectangle

# undef Block

# undef Time

# undef Date

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

# if !defined(__BORLANDC__)

#  define stat _stat

# endif

# 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

# define INT int

#else /* 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();

# ifdef __BORLANDC__

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

      { int __res;\

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

          (ret) = __STX_API_CALL4((void*)recv,(void *)_get_osfhandle(fileno(f)), (void *)(cp), (void *)(n), (void *)0);\

        else \

          (ret) = __STX_C_CALL3((void*)_rtl_read,(void *)fileno(f), (void *)(cp), (void *)(n));\

      }

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

      { int __res;\

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

          (ret) = __STX_API_CALL4((void*)send,(void *)_get_osfhandle(fileno(f)), (void *)(cp), (void *)(n), (void *)0);\

        else \

          (ret) = __STX_C_CALL3((void*)_rtl_write,(void *)fileno(f), (void *)(cp), (void *)(n));\

      }

# else /* MSC */

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

      { int __res;\

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

          (ret) = __STX_API_CALL4((void*)recv,(void *)_get_osfhandle(fileno(f)), (void *)(cp), (void *)(n), (void *)0);\

        else { \

          (ret) = __STX_API_CALL5((void*)ReadFile,(void *)_get_osfhandle(fileno(f)), (void *)(cp), (void *)(n),(void *)&__res,(void *)0);\

          if (ret) \

            ret = __res; \

        } \

      }

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

      { int __res;\

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

          (ret) = __STX_API_CALL4((void*)send,(void *)_get_osfhandle(fileno(f)), (void *)(cp), (void *)(n), (void *)0);\

        else {\

          (ret) = __STX_API_CALL5((void*)WriteFile,(void *)_get_osfhandle(fileno(f)), (void *)(cp), (void *)(n),(void *)&__res,(void*)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)

//#define __WRITING__(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) = __MKSMALLINT((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;                \

                __offs++;                               \

            } 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 GETFLAGS(fd) 0

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

#  define SETNONBLOCKING(fd) /* nothing */

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

                __offs++;                               \

                continue;                               \

            }                                           \

            CLEAR_ERRNO;                                \

            {                                           \

              int res, __cnt;                                  \

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

                  if (res > 0) {                        \

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

                        res = (cnt)-__offs;             \

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

                  } else {                              \

                      __cnt = 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(__cnt ,f, (buf)+__offs, res);   \

                  } else                                \

                      __cnt = 0;                          \

              } else {                                  \

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

              }                                         \

              if (__cnt < 0) {                            \

                  if (__threadErrno == EINTR) {                   \

                      continue;                           \

                  }                                       \

                  break;                                  \

              }                                           \

              __offs += __cnt;                            \

            }                                           \

            break;                                      \

        }                                               \

        if (__offs > 0)                                 \

            (ret) = __offs;                             \

    }                                                   \

  }

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

  {                                                     \

    int __ooffs = obj_offs;                             \

    int __offs = 0;                                     \

    int __cnt;                                          \

    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[1024];                           \

            OBJ rA = __INST(readAhead);                 \

            if (rA != nil) {                            \

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

                __INST(readAhead) = nil;                \

                __offs++;                               \

            } else {                                    \

                int l;                                  \

                CLEAR_ERRNO;                            \

                l = (cnt)-__offs;                       \

                if ( l > 1024)                          \

                  l = 1024;                             \

                READ(__cnt, f, __buf, l);               \

                if (__cnt <= 0) {                       \

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

                        continue;                       \

                    }                                   \

                    break;                              \

                }                                       \

            }                                           \

            /* refetch */                               \

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

            memcpy((buf)+__ooffs+__offs,__buf, __cnt);  \

            __offs += __cnt;                            \

        }                                               \

        if (__offs > 0)                                 \

            (ret) = __offs;                             \

    }                                                   \

  }

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

  {                                                  \

    int __ooffs = obj_offs;                          \

    int __offs = 0;                                  \

    int __cnt;                                       \

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