stdio

/* Copyright 1996 Acorn Computers Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* stdio.c: ANSI draft (X3J11 Oct 86) library code, section 4.9 */
/* Copyright (C) Codemist Ltd, 1988         */
/* Copyright (C) Acorn Computers Ltd., 1988 */
/* version 0.17e */

/* Incorporate _sys_tmpnam_ idea from WGD */

/* __pos of a file is now a long, and we avoid warnings by two casts        */
/* of this to (int) in the calls to _sys_seek().                            */
/* N.B. I am trying to factor out machine dependence via calls to           */
/* routines like _sys_read_ which can be implemented as _osgbpb or          */
/* NIOP as required.  This file SHOULD therefore be machine independent     */

/* the #include <stdio.h> imports macros getc/putc etc.  Note that we
   must keep the two files in step (more details in ctype.c).
*/

#define __system_io 1      /* makes stdio.h declare more */

#include "hostsys.h"   /* _sys_alloc() etc */
#include <stdio.h>     /* macros for putc, getc, putchar, getchar */
#include <string.h>    /* for memcpy etc */
#include <stddef.h>    /* for size_t etc */
#include <stdlib.h>    /* for free() */
#include <time.h>      /* for time() for tmpfil() */
#include <errno.h>

#include "kernel.h"    /* debug */
#include "hostsys.h"

extern char *_kernel_getmessage(char *msg, char *tag);
extern int _fprintf_lf(FILE *fp, const char *fmt, ...);
extern int _sprintf_lf(char *buff, const char *fmt, ...);

/* HIDDEN EXPORTS */
int __dup(int new, int old);
int _fisatty(FILE *stream);
int __backspace(FILE *stream);  /* strict right inverse of getc() */

#ifndef _SYS_OPEN
/* Temp feature to cope with upgrade path of compiler */
#define _SYS_OPEN SYS_OPEN
#endif

#ifndef EDOM
#define EDOM 1
#endif

#define NO_DEBUG

/* in the shared library world, __iob and _errno are generated by s.clib, */
/* in order to make it easier to keep their position fixed               */

/*FILE __iob[_SYS_OPEN];*/
/* Note that the real name for errno is _errno, and the macro errno is   */
/* defined in errno.h                                                    */
/*volatile int errno;*/

typedef struct __extradata {
  /*
   * BODGE BODGE BODGE BODGE
   * sscanf needs to know the size of this structure, so if you change
   * it, alter sscanf's view of it.
   */
  unsigned char __lilbuf[2]; /* single byte buffer for them that want it  */
                            /* plus an unget char is put in __lilbuf[1]   */
  long _lspos;              /* what __pos should be (set after lazy seek) */
  unsigned char *__extent;   /* extent of writes into the current buffer  */
  int __buflim;              /* used size of buffer                       */
  int __savedicnt;           /* after unget contains old icnt             */
  int __savedocnt;           /* after unget contains old ocnt             */
} _extradata, *_extradatap;

static _extradatap _extra;

#define EXTENT(stream) ((stream)->__extrap->__extent > (stream)->__ptr \
                       ? (stream)->__extrap->__extent : (stream)->__ptr)

/* Explanation of the _IOxxx bits:                                       */
/* IONOWRITES says that the file is positioned at the end of the current */
/* buffer (as when performing sequential reads), while IODIRTIED         */
/* indicates that its position is at the start of the current buffer (as */
/* in the usual case when writing a file). When the relevant bit is not  */
/* set and a transfer is needed _sys_seek() is used to reposition the    */
/* file. Now extra bit _IOSEEK indicating that repositioning of the file */
/* is required before performing I/O                                     */
/* Extra bit _IOLAZY added to indicate that a seek has been requested    */
/* but has been deferred until the next fill or flush buffer             */
/* I use IONOWRITES and IONOREADS to check the restriction               */
/* that read and write operations must be separated by fseek/fflush.     */

/* N.B. bits up to (and including 0xfff) in <stdio.h>, as below:         */
#ifdef never
#define _IOREAD     0x00000001     /* open for input */
#define _IOWRITE    0x00000002     /* open for output */
#define _IOBIN      0x00000004     /* binary stream */
#define _IOSTRG     0x00000008     /* string stream */
#define _IOSEEK     0x00000010     /* physical seek required before IO */
#define _IOLAZY     0x00000020     /* possible seek pending */
#define _IOEOF      0x00000040     /* end-of-file reached */
#define _IOERR      0x00000080     /* error occurred on stream */
#define _IOFBF      0x00000100     /* fully buffered IO */
#define _IOLBF      0x00000200     /* line buffered IO */
#define _IONBF      0x00000400     /* unbuffered IO */
#define _IOSBF      0x00000800     /* system allocated buffer */
#define _IOAPPEND   0x00008000     /* must seek to eof before write */
#endif
#define _IONOWRITES 0x00001000     /* last op was a read                 */
#define _IONOREADS  0x00002000     /* last op was a write                */
#define _IOPEOF     0x00004000     /* 'pending' EOF                      */
#define _IODIRTIED  0x00010000     /* buffer has been written to         */
#define _IOBUFREAD  0x00020000     /* indicates that the buffer being    */
                                   /* written was read from file, so a   */
                                   /* seek to start of buffer is required*/
#define _IOADFSBUG  0x00040000     /* indicates that the underlying      */
                                   /* system buffer was last written to  */
                                   /* and an ensure should be done if    */
                                   /* a seek is about to happen before   */
                                   /* the next read is performed         */
#define _IOUNGET    0x00080000     /* last op was an unget               */
#define _IOSHARED   0x00100000     /* 2 streams share the same file      */
#define _IOUSERFILE 0x00200000     /* set if should be closed by user    */
                                   /* terminateio in a module            */
#define _IOACTIVE   0x00400000     /* some IO operation already performed*/
#define _IODEL      0xad800000     /* for safety check 9 bits            */
#define _IODELMSK   0xff800000

/* first functions for macros in <stdio.h>  */
int (fgetc)(FILE *stream) { return getc(stream); }
int (fputc)(int ch, FILE *stream) { return putc(ch, stream); }
int (getc)(FILE *stream) { return getc(stream); }
int (getchar)() { return getchar(); }
int (putc)(int ch, FILE *stream) { return putc(ch, stream); }
int (putchar)(int ch) { return putchar(ch); }
int (feof)(FILE *stream) { return feof(stream); }
int (ferror)(FILE *stream) { return ferror(stream); }
#define STDOUT stderr
#ifdef DEBUG
#define dbmsg(m, m2) if (stream > STDOUT || stream == stdin) {int last ;int iw; char v[128]; \
        sprintf(v, m, m2); \
        for(iw=0;v[iw];_kernel_oswrch(last=v[iw++])); \
        if (last = 10)_kernel_oswrch(13);}
#define dbmsg_noNL(m, m2) if (stream > STDOUT || stream == stdin) {int last ;int iw; char v[128]; \
        sprintf(v, m, m2); \
        for(iw=0;v[iw];_kernel_oswrch(last=v[iw++]));}
#else
#define dbmsg(m, m2)
#define dbmsg_noNL(m, m2)
#endif
/* put this here too */
void clearerr(FILE *stream)
{   /* we should do more in 'clearerr' resetting __pos __ptr and _cnt      */
    if (!stream) return;
    stream->__flag &= ~(_IOEOF+_IOERR+_IOPEOF);
}

#define seterr(stream) ((stream)->__flag |= _IOERR, \
                        (stream)->__icnt = (stream)->__ocnt = 0)

int setvbuf(FILE *stream, char *buf, int type, size_t size)
{   int flags = stream -> __flag;
    unsigned char *ubuf = (unsigned char *) buf;   /* costs nothing */
    if ((!(flags & _IOREAD+_IOWRITE)) || (flags & _IOACTIVE))
        return 1;             /* failure - not open || already active */
    switch (type)
    {   default: return 1;    /* failure */
        case _IONBF:
            ubuf = stream->__extrap->__lilbuf;
            size = 1;
            break;
        case _IOLBF:
        case _IOFBF:
            if (size-1 >= 0xffffff) return 1;  /* unsigned! */
            break;
    }
    stream->__ptr = stream->__base = ubuf;
    stream->__bufsiz = size;
    stream->__flag = (stream->__flag & ~(_IOSBF+_IOFBF+_IOLBF+_IONBF)) | type;
    return 0;                 /* success */
}

void setbuf(FILE *stream, char *buf)
{
   (void) setvbuf(stream, buf, (buf!=0 ? _IOFBF : _IONBF), BUFSIZ);
}

int __backspace(FILE *stream)
{
    if (!(stream->__flag & _IOEOF) &&
         (stream->__ptr > stream->__base))
    {   ++(stream->__icnt);
        --(stream->__ptr);
        return 0;
    }
    return EOF;
}

int ungetc(int c,FILE *stream)
{   /* made into a fn to evaluate each arg once. */
    if (c==EOF || (stream->__flag & (_IOUNGET+_IONOREADS))) return EOF;
    /* put char into unget buffer */
    stream->__extrap->__lilbuf[1] = c;
    stream->__flag = (stream->__flag | _IOUNGET | _IONOWRITES | _IOACTIVE) & ~(_IOEOF);
    stream->__extrap->__savedocnt = stream->__ocnt;
    stream->__extrap->__savedicnt = stream->__icnt;
    stream->__icnt = stream->__ocnt = 0;
    return c;
}

static int _writebuf(unsigned char *buf, int len, FILE *stream)
{   int w;
    FILEHANDLE fh = stream->__file;
    int flag = stream->__flag;
    if (flag & _IOSHARED) /* this is really gross */
    {   flag |= _IOSEEK;
        stream->__pos = _sys_flen(fh);
dbmsg("_IOSHARED so zoom to end %d\n", (int)stream->__pos);
    }
    if (flag & _IOSEEK+_IOBUFREAD)
    {
dbmsg("_writebuf seeking to %d\n", (int)stream->__pos);
        if (_sys_seek(fh, (int)stream->__pos) < 0)
        {   seterr(stream);
            return EOF;
        }
        stream->__flag = (flag &= ~(_IOSEEK+_IOBUFREAD));
    }
dbmsg_noNL("_writebuf pop goes the stoat %i, ", fh);
dbmsg_noNL("%X, ", buf);
dbmsg_noNL("%d, ", len);
dbmsg("%X\n", flag);
    w = _sys_write(fh, buf, len, flag);
    stream->__flag |= _IOADFSBUG;
dbmsg("_sys_write_ returned %d\n", w);
    stream->__pos += len - (w & 0x7fffffffL);
    if (w!=0)    /* AM: was (w<0) but trap unwritten chars as error too */
    {   seterr(stream);
        return(EOF);
    }
dbmsg("filelen = %d\n",_sys_flen(fh));           /* length of this file      */
    return 0;
}

static int _fflush(FILE *stream)
{
    unsigned char *buff = stream->__base;
    unsigned char *extent = EXTENT(stream);
dbmsg("%s\n", "_fflush");
    stream->__flag &= ~_IOUNGET;
    if ((stream->__flag & _IOREAD+_IOWRITE) == _IOREAD) return 0;
    if ((stream->__flag & _IOERR+_IOWRITE) != _IOWRITE) return EOF;
    /* N.B. really more to do here for ANSI input stream */
    if (stream->__flag & _IODIRTIED)
    {   /* only write if dirty buffer - this avoids problems with
           writing to a file opened in append (or read+write) mode
           when only input has been done since the last fflush/fseek.
        */
dbmsg("%s\n", "dirty buffer");
        if (extent != buff)       /* something to do */
        {
dbmsg("%s\n", "call _writebuf");
          if (_writebuf(buff, extent - buff, stream)) return EOF;
        }
        stream->__ptr = stream->__extrap->__extent = extent = buff;
/* the next line forces a call to __filbuf/__flsbuf on next putc/getc -  */
/* this is necessary since change of direction may happen.               */
        stream->__ocnt = 0;
        stream->__flag &= ~_IODIRTIED;
dbmsg("%s\n", "clear IODIRTIED");
    }
else dbmsg("%s\n", "not a dirty buffer");

/* now do quick frig to fix I/O streams: essentially fseek(s, 0, SEEK_CUR).
    if ((stream->__flag & (_IOREAD+_IOWRITE)) == (_IOREAD+_IOWRITE))
    {
      stream->__flag = stream->__flag & ~(_IOEOF|_IONOWRITES|_IOREADS|_IOPEOF)
                                                                   |_IOSEEK;
      stream->__icnt = stream->__ocnt = 0;
      stream->__pos += (extent - buff);
      stream->__ptr = buff;
    }
*/

    return 0;
}

static void _deferredlazyseek(FILE *stream)
{
dbmsg("deferredlazyseek to %d\n", (int)stream->__extrap->_lspos);
    /* only here because of a seek */
    stream->__flag &= ~_IOLAZY;
    if (stream->__pos != stream->__extrap->_lspos) {
      _fflush(stream);
      /* clear EOF condition */
dbmsg("%s\n", "clear IODIRTIED");
      stream->__flag = stream->__flag & ~(_IONOWRITES | _IONOREADS) | _IOSEEK;
      stream->__pos = stream->__extrap->_lspos;
      stream->__ptr = stream->__extrap->__extent = stream->__base;
    }
else dbmsg("%s\n", ".....already there");
    stream->__flag &= ~(_IOEOF | _IOPEOF);
}

extern int __flsbuf(int ch, FILE *stream)
{   int flag;
dbmsg_noNL("%s ", "__flsbuf");
dbmsg("%c\n", ch);
    stream->__flag = (stream->__flag & ~_IOUNGET) | _IOACTIVE;

    if (stream->__flag & _IOLAZY) _deferredlazyseek(stream);

    if ((stream->__ocnt < -1) && !(stream->__flag & _IOLBF)) {
      /* buffer ~empty, sequence of events that lead to here are :          */
      /* put seek get seek put                                              */
dbmsg("flushbuf negative ocnt = %d\n", stream->__ocnt);
      stream->__ocnt = (-stream->__ocnt) - 2;
      stream->__flag |= (_IODIRTIED+_IONOREADS);           /* we are writing */
      return *(stream->__ptr)++ = (ch);
    }

    flag = stream->__flag;
    if ((flag & _IOERR+_IOSTRG+_IOWRITE+_IONOWRITES) != _IOWRITE)
    {   seterr(stream);
dbmsg("%s\n", "!= _IOWRITE");
        return EOF;
    }
/* the next conditional code is ACN's view of that APPEND means seek to     */
/* EOF after EVERY fflush, not just initially.  Hmm, ANSI really should     */
/* clarify - the problem is perhaps that we wish to seek to EOF after       */
/* fflush after read, but not after fflush after write?                     */
/* The line "if ((flag & (_IOSEEK+_IOAPPEND)) == (_IOSEEK+_IOAPPEND))"      */
/* which PH10 suggested does not work, try the sequence:                    */
/* create file with something in it; close file; open the file (append mode)*/
/* seek to start; write a char; THE CHAR WRITTEN IS NOT WRITTEN TO EOF      */
/* The following line has been reinstated cos it works.                     */
    if ((flag & (_IONOREADS+_IOSEEK+_IOAPPEND)) == _IOAPPEND)
/* Will somebody please help ACN remember/understand what was going on here!*/
    {   /* first write to APPEND file after FFLUSH, but not FSEEK nor       */
        /* fopen (does its own FSEEK)                                       */
        fseek(stream, 0L, SEEK_END);
        if (stream->__flag & _IOLAZY) _deferredlazyseek(stream);
        flag = stream->__flag;
    }
dbmsg("%s\n", "set IODIRTIED");
    stream->__flag = (flag |= (_IODIRTIED+_IONOREADS));    /* we are writing */
    if (stream->__base == NULL)
    {   if (_sys_istty(stream)) {         /* terminal - unbuffered  */
            stream->__ptr = stream->__base = stream->__extrap->__lilbuf;
            stream->__bufsiz = 1;
            stream->__flag = (flag |= _IONBF);
        } else {
            /* allocate default system buffer */
            stream->__ptr = stream->__base = _sys_alloc(stream->__bufsiz);
            stream->__flag |= (flag |= _IOSBF);
            if ((flag & _IOLBF+_IOFBF) == 0) stream->__flag |= (flag |= _IOFBF);
        }
    }
    if (flag & _IOFBF)               /* system or user buffer */
    {   unsigned char *buff = stream->__base;
        int count = EXTENT(stream) - buff;
        if (count != 0) {
            if (_writebuf(buff, count, stream)) return EOF;
        }
        stream->__ptr = stream->__extrap->__extent = buff+1;
        stream->__ocnt = stream->__bufsiz - 1;
        stream->__extrap->__buflim = stream->__bufsiz;
        return (*buff = ch);
    }
    else     /* no buffer (i.e. 1 char private one) or line buffer */
    {   unsigned char *buff = stream->__base;
        int count;
        *stream->__ptr++ = ch;   /* always room */
        count = EXTENT(stream) - buff;
        stream->__extrap->__buflim = stream->__bufsiz;
        if ((flag & _IONBF) ||
               (unsigned char)ch == '\n' || count >= stream->__bufsiz)
        {   stream->__ptr = stream->__extrap->__extent = buff;
            stream->__ocnt = 0;                 /* 2^31 is big but finite */
            return _writebuf(buff, count, stream) ? EOF : (unsigned char)ch;
        }
        return (unsigned char)ch;
    }
}

extern int __filbuf(FILE *stream)
{   int w;
    unsigned char *buff;
    FILEHANDLE fh;
    int request;
dbmsg("%s\n", "__filbuf");
    stream->__flag |= _IOACTIVE;
    if (stream->__flag & _IOUNGET) {
      stream->__icnt = stream->__extrap->__savedicnt;
      stream->__ocnt = stream->__extrap->__savedocnt;
      stream->__flag &= ~_IOUNGET;
      return stream->__extrap->__lilbuf[1];
    }

    if (stream->__flag & _IOLAZY) _deferredlazyseek(stream);

    /* note that sscanf (q.v.) requires this next line to yield EOF */
    if ((stream->__flag & (_IOEOF+_IOERR+_IOSTRG+_IOREAD+_IOPEOF+_IONOREADS))
                                                                    != _IOREAD)
    {   stream->__icnt = 0;                      /* 2^31 is big but finite */
        if (stream->__flag & _IOEOF+_IOPEOF+_IOSTRG)
            /* writing ok after EOF read according to ansi */
            stream->__flag = stream->__flag & ~(_IONOWRITES+_IOPEOF) | _IOEOF;
        else seterr(stream);
        return(EOF);
    }

    if ((stream->__flag & _IOSBF+_IONBF+_IODIRTIED) == 0)
    if ((stream->__base == NULL) && ((stream->__flag & _IODIRTIED) == 0))
    {
            /* allocate default system buffer */
            stream->__ptr = stream->__base = _sys_alloc(stream->__bufsiz);
            stream->__flag |= _IOSBF;
            if ((stream->__flag & _IOLBF+_IOFBF) == 0) stream->__flag |= _IOFBF;
    }

    if (stream->__icnt < -1) {
      /* buffer ~empty, came here cos seek wanted to to tidy up flags etc */
dbmsg("fillbuf negative icnt = %d\n", stream->__icnt);
      stream->__icnt = (-stream->__icnt) - 2;
      stream->__flag |= _IONOWRITES;           /* we are reading */
      return *(stream->__ptr)++;
    }

    fh = stream->__file;
    if (stream->__flag & _IOSEEK) {
      if (stream->__flag & _IODIRTIED) _fflush(stream);
      else {
dbmsg("fillbuf seeking to %d\n", (int)stream->__pos);
        if (stream->__flag & _IOADFSBUG) {
          _sys_ensure(fh);
          stream->__flag &= ~_IOADFSBUG;
        }
        if (_sys_seek(fh, (int)stream->__pos) < 0)
        {   seterr(stream);
            return EOF;
        }
      }
    }

    stream->__flag |= _IONOWRITES;           /* we are reading */

    if (stream->__flag & _IODIRTIED) {
      int extent = (int) (EXTENT(stream) - stream->__base);
      request = stream->__bufsiz - extent;
      if (request == 0) {
        _fflush(stream);
        request = stream->__bufsiz;
      } else {
dbmsg("fillbuf flag %X\n", stream->__flag);
        if ((stream->__flag & (_IOBUFREAD+_IOSEEK)) == 0) {
dbmsg("fillbuf dirty buffer, read into end,seeking to %d\n",(int) stream->__pos+extent);
          if (stream->__flag & _IOADFSBUG) {
            _sys_ensure(fh);
            stream->__flag &= ~_IOADFSBUG;
          }
          if (_sys_seek(fh, (int) stream->__pos + extent) < 0)
          {   seterr(stream);
              return EOF;
          } else stream->__flag |= _IOBUFREAD;
        }
      }
      buff = stream->__base + (stream->__bufsiz - request);
dbmsg_noNL("fillbuf not splatting out writ part of file request %d ", request);
dbmsg("at buff %X\n", (int)buff);
    } else {
      request = stream->__bufsiz;
      buff = stream->__base;
      stream->__pos += stream->__ptr - buff;     /* add buf size for ftell() */
    }
    stream->__flag &= ~_IOSEEK;


dbmsg("READING FROM FILE REQUEST = %d\n", request);
dbmsg("filelen = %d\n",_sys_flen(fh));             /* length of this file */
    stream->__icnt = 0;
    w = _sys_read(fh, buff, request, stream->__flag);
    stream->__flag &= ~_IOADFSBUG;
dbmsg("_sys_read_ returned %d\n", w);
    if (w<0) {
      if (w == _kernel_ERROR) { seterr(stream); return EOF; }
      /* this deals with operating systems with 'early' eof */
      stream->__flag |= _IOPEOF;
      w = w & 0x7fffffff;
    }
    w = request - w;
dbmsg("read %d bytes\n", w);
    stream->__extrap->__extent = buff + w;
    stream->__extrap->__buflim = stream->__bufsiz;
    if (w==0)    /* this deals with operating systems with 'late' eof  */
    {   stream->__flag |= _IOEOF;                /* is this case independent? */
        stream->__flag &= ~_IONOWRITES;          /* writing OK after EOF read */
        stream->__icnt = 0;
        stream->__ptr = buff;  /* just for fun - NB affects ftell() - check */
        return(EOF);
    }
    else
    {   stream->__icnt = w-1;
        stream->__ptr = buff+1;
        stream->__flag |= _IOBUFREAD;
        return(buff[0]);
    }
}

static int _fillb2(FILE *stream)
{   if (__filbuf(stream) == EOF) return EOF;
    stream->__icnt++;
    stream->__ptr--;
    return 0;
}

int fclose(FILE *stream)
{   /* MUST be callable on a closed file - if stream clr then no-op. */
    FILEHANDLE fh;
    unsigned char *buff;
    int flag;
    _extradatap extrap;
    int res = 0;

    /* Deal with programs calling fclose(0), ECN 21-09-93 */
    if (!stream) return EOF;
    fh = stream->__file;
    buff = stream->__base;
    flag = stream->__flag;
    extrap = stream->__extrap;
    if (!(flag & _IOREAD+_IOWRITE)) return EOF;   /* already closed    */
    if (!(flag & _IOSTRG))                    /* from _fopen_string    */
    {   int fd = _SYS_OPEN;
        res = fflush(stream);
        if (flag & _IOSHARED)
        {   for (fd =  0;  fd < _SYS_OPEN;  ++fd)
            {   FILE *f = &__iob[fd];
                if ((f != stream) &&
                    (f->__flag & _IOREAD+_IOWRITE) &&     /* f is open */
                    (f->__file == fh) && (f->__flag & _IOSHARED))
                {   f->__flag &= ~_IOSHARED;       /* no longer shared */
                    stream->__flag &= ~_IOSHARED;
                    break;
                }
            }
        }
        /* Assert: fd != SYS_OPEN => fh is shared and mustn't be closed */
        if (fd == _SYS_OPEN &&
            _sys_close(fh) < 0) res = EOF;          /* close real file */
        if (flag & _IOSBF) free(buff);         /* free buffer if system */
        if ((flag & _IODELMSK) == _IODEL)
        {   char name[L_tmpnam];
            _sys_tmpnam_(name, stream->__signature);
            if (remove(name) != 0) res = EOF; /* delete the file if pos */
        }
    }
    memclr(stream->__extrap, sizeof(_extradata));
    memclr(stream, sizeof(FILE));
    stream->__extrap = extrap;
    return res;
}

FILE *freopen(const char *name, const char *mode, FILE *iob)
{
/* The use of modes "r+", "w+" and "a+" is not fully thought out   */
/* yet, in that calls to __flsbuf may write back stuff that was    */
/* loaded by __filbuf and thereby corrupt the file.                */
/* This is now just about fixed given the ANSI restriction that    */
/* calls to getc/putc must be fflush/fseek separated.              */
    FILEHANDLE fh;
    int flag, openmode;        /* nasty magic numbers for openmode */
    fclose(iob);
    switch (*mode++)
    {   default:  return(NULL);               /* mode is incorrect */
        case 'r': flag = _IOREAD;  openmode = OPEN_R; break;
        case 'w': flag = _IOWRITE; openmode = OPEN_W; break;
        case 'a': flag = _IOWRITE | _IOAPPEND;
                                   openmode = OPEN_A; break;
    }
    for (;;)
    {   switch (*mode++)
        {
    case '+':   flag |= _IOREAD+_IOWRITE, openmode |= OPEN_PLUS;
                continue;
    case 'b':   flag |= _IOBIN, openmode |= OPEN_B;
                continue;
        }
        if (*(mode-1) == 't') openmode |= OPEN_T;
        break;
    }
    if ((fh = _sys_open(name, openmode)) == NONHANDLE) return NULL;
    if (_kernel_client_is_module()) flag |= _IOUSERFILE;
    iob->__ptr = iob->__base = NULL; iob->__bufsiz = BUFSIZ;
    iob->__flag = flag;
    iob->__file = fh;
    if (openmode & OPEN_A) fseek(iob, 0L, SEEK_END);  /* a or a+             */
    return iob;
}

FILE *fopen(const char *name, const char *mode)
{   int i;
    for (i=3; i<_SYS_OPEN; i++)
    {   FILE *stream = &__iob[i];
        if (!(stream->__flag & _IOREAD+_IOWRITE))  /* if not open then try it */
            return (freopen(name, mode, stream));
    }
    return 0;   /* no more i/o channels allowed for */
}

FILEHANDLE __dup(int new, int old)
{   FILE *s_new, *s_old;
    (void) fclose(&__iob[new]);
    s_new = &__iob[new];
    s_old = &__iob[old];
    s_old->__flag |= _IOSHARED;
    s_new->__flag = s_old->__flag & (_IOREAD+_IOWRITE+_IOAPPEND+_IOSHARED+
                                              _IOSBF+_IOFBF+_IOLBF+_IONBF);
    s_new->__file = s_old->__file;
    return s_new->__file;
}

FILE *_fopen_string_file(const char *data, int length)
{
/* open a file that will read data from the given string argument        */
/* The declaration of this function in #include "hostsys.h" suggests     */
/* that this function is of type (void *), so this definition will lead  */
/* to a warning message.                                                 */
    int i;
    for (i=3; i<_SYS_OPEN; i++)
    {   FILE *stream = &__iob[i];
        if (!(stream->__flag & _IOREAD+_IOWRITE))  /* if not open then try it */
        {
            fclose(stream);
            stream->__flag = _IOSTRG+_IOREAD+_IOACTIVE;
            stream->__ptr = stream->__base = (unsigned char *)data;
            stream->__icnt = length;
            return stream;
        }
    }
    return 0;   /* no more i/o channels allowed for */
}

int _fisatty(FILE *stream)  /* not in ANSI, but related needed for ML */
{   if ((stream->__flag & _IOREAD) && _sys_istty(stream)) return 1;
    return 0;
}

/* initialisation/termination code... */


void _initio(char *f1,char *f2,char *f3)
{
    int i;
    char v[128];
    memclr(__iob, _SYS_OPEN*sizeof(FILE));
/*  _extra = calloc(_SYS_OPEN, sizeof(_extradata)); */
    _extra = _sys_alloc(_SYS_OPEN * sizeof(_extradata));
    memclr(_extra, _SYS_OPEN * sizeof(_extradata));
    for (i=0; i<_SYS_OPEN; i++) __iob[i].__extrap = _extra+i;
    /* In the next lines DO NOT use standard I/O for error msgs (not open yet)
       Moreover, open in this order so we do not create/overwrite output if
       input does not exist. */
    if (freopen(f3, "w", stderr) == 0)
        _sprintf_lf(v,_kernel_getmessage("Couldn't write %s", "C46"), f3), _sys_msg(v), exit(1);
    if (freopen(f1, "r", stdin) == 0)
        _sprintf_lf(v,_kernel_getmessage("Couldn't read %s", "C47"), f1), _sys_msg(v), exit(1);
    if (freopen(f2, "w", stdout) == 0)
        _sprintf_lf(v,_kernel_getmessage("Couldn't write %s", "C46"), f2), _sys_msg(v), exit(1);
}

void _terminateio()
{   int i;
    int closeall = !_kernel_client_is_module();
    for (i=3; i<_SYS_OPEN; i++) {
        FILE *f = &__iob[i];
        if (closeall || (f->__flag & _IOUSERFILE)) fclose(f);
    }
    /* for cowardice do stdin, stdout, stderr last (in that order) */
    for (i=0; i<3; i++) {
        FILE *f = &__iob[i];
        if (closeall || (f->__flag & _IOUSERFILE)) {
            fclose(f);
            if (!closeall) freopen(TTYFILENAME, (f == stdin ? "r" : "w"), f);
        }
    }
    if (_extra) {
        free(_extra);
        _extra = 0;
    }
}


/* now the less machine dependent functions ... */

char *fgets(char *s, int n, FILE *stream)
{   char *a = s;
    if (n <= 1) return NULL;                  /* best of a bad deal */
    do { int ch = getc(stream);
         if (ch == EOF)                       /* error or EOF       */
         {   if (s == a) return NULL;         /* no chars -> leave  */
             if (ferror(stdin)) a = NULL;
             break; /* add NULL even if ferror(), spec says 'indeterminate' */
         }
         if ((*s++ = ch) == '\n') break;
       }
       while (--n > 1);
    *s = 0;
    return a;
}

char *gets(char *s)
{   char *a = s;
    for (;;)
    {    int ch = getc(stdin);
         if (ch == EOF)                       /* error or EOF       */
         {   if (s == a) return NULL;         /* no chars -> leave  */
             if (ferror(stdin)) a = NULL;
             break; /* add NULL even if ferror(), spec says 'indeterminate' */
         }
         if (ch == '\n') break;
         *s++ = ch;
    }
    *s = 0;
    return a;
}

int fputs(const char *s, FILE *stream)
{
    char c;
    while((c = *s++) != 0)
        if(putc(c, stream)==EOF) return(EOF);
    return(0);
}

int puts(const char *s)
{
    char c;
    while ((c = *s++) != 0)
       if (putchar(c) == EOF) return EOF;
    return putchar('\n');
}

/* _read improved to use __filbuf and block moves.  Optimisation
   to memcpy too if word move.  Still possible improvments avoiding copy
   but I don't want to do these yet because of interactions
   (e.g. __pos of a file).   N.B.  _read is not far from unix 'read' */
static int _read(char *ptr, int nbytes, FILE *stream)
{   int i = nbytes;
dbmsg("%s\n", "_read");
    if (i == 0) return 0;
    if (stream->__flag & _IOUNGET) {
      *ptr++ = __filbuf(stream); i--;
    }
    if (stream->__flag & _IOLAZY) _deferredlazyseek(stream);
    do
    {
dbmsg("in _read, icnt = %d\n", stream->__icnt);
        if (i <= stream->__icnt)
        {   memcpy(ptr, stream->__ptr, i);
            stream->__icnt -= i; stream->__ptr += i;
            return nbytes;
        }
        else if (stream->__icnt >= 0)
        {   memcpy(ptr, stream->__ptr, stream->__icnt);
            ptr += stream->__icnt, i -= stream->__icnt;
            stream->__ptr += stream->__icnt, stream->__icnt = -1; /* for __pos */
        }
        else stream->__icnt--;
    } while (_fillb2(stream) != EOF);
    return nbytes-i;
/*
    for (i=0; i<nbytes; i++)
    {   if ((ch = getc(stream)) == EOF) return i;
        *ptr++ = ch;
    }
    return nbytes;
*/
}

size_t fread(void *ptr, size_t itemsize, size_t count, FILE *stream)
{    /* ANSI spec says EOF and ERR treated the same as far as fread
      * is concerned and that the number of WHOLE items read is returned.
      */
dbmsg("fread %d\n", count);
    return itemsize == 0 ? 0   /* slight ansi irrationality */
                         : _read(ptr, itemsize*count, stream) / itemsize;
}

static int _write(const char *ptr, int nbytes, FILE *stream)
{   int i;
    for(i=0; i<nbytes; i++)
        if (putc(*ptr++, stream) == EOF) return 0;
        /* H&S say 0 on error */
    return nbytes;
}

size_t fwrite(const void *ptr, size_t itemsize, size_t count, FILE *stream)
{
/* The comments made about fread apply here too */
dbmsg("fwrite %d\n", count);
    return itemsize == 0 ? count
                         : _write(ptr, itemsize*count, stream) / itemsize;
}

/* back to machine dependent functions */

#define _ftell(stream) (  (stream)->__flag & _IOLAZY \
                        ? (stream)->__extrap->_lspos \
                        : (stream)->__pos + (stream)->__ptr - (stream)->__base)

long int ftell(FILE *stream)
{  long pos;
   if (!(stream->__flag & _IOREAD+_IOWRITE))     /* already closed        */
   { errno = EDOM;
     return -1L;
   }
   pos = _ftell(stream);
   if (stream->__flag & _IOUNGET && pos > 0) --pos;
   return pos;
}

/* The treatment of files that can be written to seems complicated in fseek */

int fseek(FILE *stream, long int offset, int whence)
{
    FILEHANDLE fh = stream->__file;
    int flag = stream->__flag;
dbmsg_noNL("%s ", "SEEK ENTRY");

    if (!(flag & _IOREAD+_IOWRITE+_IOSHARED) || _sys_istty(stream))
        return(2);                              /* fseek impossible  */

    switch(whence)
    {
case SEEK_SET:
        break;                                  /* relative to file start */
case SEEK_CUR:
        offset += ftell(stream);                /* relative seek */
        break;
case SEEK_END:
        {   long int filelen, filepos;
            filelen = _sys_flen(fh);           /* length of this file      */
dbmsg("filelen in seek = %d\n", (int)filelen);
            if (filelen<0)                      /* failed to read length    */
            {   seterr(stream);
                return 1;
            }
            filepos = stream->__pos + EXTENT(stream) - stream->__base;
            if (stream->__flag & _IOLAZY && filepos < stream->__extrap->_lspos)
              filepos = stream->__extrap->_lspos;
            if (filepos>filelen)                /* only possible on write   */
                filelen = filepos;              /* allow for stuff buffered */
            offset += filelen;                  /* relative to end of file  */
        }
        break;
default:
        seterr(stream);
        return(2);                              /* illegal operation code   */
    }

    if (offset < 0) { seterr(stream); return 2; } /* fseek impossible  */

    if ((flag & _IONOREADS) && stream->__extrap->__extent < stream->__ptr)
      stream->__extrap->__extent = stream->__ptr;

dbmsg_noNL("%s ", "SEEK");
dbmsg_noNL("__pos %d", (int)stream->__pos);
dbmsg_noNL(" offset %d", (int)offset);
dbmsg_noNL(" buflim %d", stream->__extrap->__buflim);
dbmsg_noNL(" __ptr %X", (int)stream->__ptr);
dbmsg_noNL(" __icnt %d", stream->__icnt);
dbmsg_noNL(" __ocnt %d", stream->__ocnt);
dbmsg_noNL(" __base %X", (int)stream->__base);

    if (offset < stream->__pos ||
      offset > stream->__pos + EXTENT(stream) - stream->__base ||
      offset >= stream->__pos + stream->__extrap->__buflim)

      { /* outside buffer */
dbmsg("%s\n", " outside buffer");
      flag |= _IOLAZY;
      stream->__icnt = stream->__ocnt = 0;
      stream->__extrap->_lspos = offset;
    } else { /* inside buffer */
dbmsg("%s\n", " inside buffer");
      offset -= stream->__pos;
      if (flag & _IOWRITE)
        stream->__ocnt = -(stream->__extrap->__buflim - (int)offset);
      if (flag & _IOREAD)
        stream->__icnt = -((int)(EXTENT(stream) - stream->__base) - (int)offset);
      stream->__ptr = stream->__base + offset;
      flag &= ~_IOLAZY;
    }
dbmsg_noNL("AFTER SEEK __ptr %X", (int)stream->__ptr);
dbmsg_noNL(" __icnt %d", stream->__icnt);
dbmsg(" __ocnt %d\n", stream->__ocnt);
    stream->__flag = flag & ~(_IOEOF+_IONOWRITES+_IONOREADS+_IOUNGET);

    return 0;
}

static int _do_fflush(FILE *stream)
{ /* ignore the effect of a previous unget on the file position indicator by
     using _ftell rather than ftell */
  if (stream->__flag & _IOREAD+_IOWRITE)   /* not open */
  { long offset = _ftell(stream);
    int res;
dbmsg("%s\n", "fflush");
    if (stream->__flag & _IOLAZY) _deferredlazyseek(stream);
    stream->__flag &= ~(_IONOREADS+_IONOWRITES);
    res =_fflush(stream);
    fseek(stream, offset, SEEK_SET);
    return res;
  } else return 0;
}

int fflush(FILE *stream)
{ /* new definition (ANSI May 88) says that if stream == NULL, apply fflush to
     all applicable streams */
   int res = 0;
   if (stream != NULL)
     res =_do_fflush(stream);
   else
   { int i;
     for (i=0; i<_SYS_OPEN; i++)
       if (_do_fflush(&__iob[i]) != 0) res = EOF;
   }
   return res;
}

void rewind(FILE *stream)
{
   fseek(stream, 0L, SEEK_SET);
   clearerr(stream);
}

/* the following routines need to become the main entry I suppose          */
int fgetpos(FILE *stream, fpos_t *pos)
{  pos->__lo = ftell(stream);
   return 0;
}

int fsetpos(FILE *stream, const fpos_t *pos)
{  int res = fseek(stream, pos->__lo, SEEK_SET);
   if (res) errno = EDOM;
   return res;
}

static char _tmp_file_name[L_tmpnam] = "";
static int _tmp_file_sig;

char *tmpnam(char *a)
{
/* Obtaining an unique name is tolerably nasty - what I do here is       */
/* derive the name (via _sys_tmpnam_())                                  */
/* from an integer that is constructed out of a serial number combined   */
/* with the current clock setting. An effect of this is that the file    */
/* name can be reconstructed from a 32-bit integer for when I want to    */
/* delete the file. The serial number is held in zero page and is        */
/* returned and incremented by __counter(). This ensures uniqueness      */
/* if tmpnam is called from two applications within the same second.     */
    _kernel_osfile_block fb;

    if (a==NULL) a = _tmp_file_name;
    do {
      _tmp_file_sig = ((int)time(NULL) << 8) | __counter();
      _sys_tmpnam_(a, _tmp_file_sig);
    } while (_kernel_osfile(17, a, &fb) != 0);

    return a;
}

char *__old_tmpnam(char *a)
{
    return tmpnam(a);
}

FILE *tmpfile()
{
    char name[L_tmpnam];
    FILE *f;
    f = fopen(tmpnam(name), "w+b");
    if (f)
    {   f->__flag |= _IODEL;
        f->__signature = _tmp_file_sig;
    }
    return f;
}

void perror(const char *s)
{   char b[256];
    if (s != 0 && *s != 0) fprintf(stderr, "%s: ", s);
    fprintf(stderr, "%s\n", _strerror(errno, b));
}

/* end of stdio.c */