/*static char *SCCSID = "%W% %E%";*/
/*
*      Copyright Microsoft Corporation, 1983-1987
*
*      This Module contains Proprietary Information of Microsoft
*      Corporation and should be treated as Confidential.
*/
/*
 *  STANDARD I/O:
 *
 *  Standard (buffered) I/O package which is smaller and faster
 *  than the MS C runtime stdio.
 */

#include                <fcntl.h>
#include                <minlit.h>
#include                <memory.h>
#include                <io.h>
#include                <string.h>

#if NOT defined( _WIN32 )
#define i386
#endif
#include                <stdarg.h>


#if OWNSTDIO

#define STDSIZ          128                 /* Size for stdin, stdout */
#define BUFSIZ          1024                /* Size for other files */
typedef char            IOEBUF[STDSIZ];     /* For stdin, stdout */
#define _NFILE          10
#define _NSTD           2               /* # automatic stdio buffers */

LOCAL IOEBUF            _buf0;
LOCAL IOEBUF            _buf1;
LOCAL int               cffree = _NFILE - _NSTD;

#if DOSX32              // hack needed untill the libc.lib is fixed
int _cflush;
#endif


/*
 * typedef struct file
 *   {
 *     char             *_ptr;
 *     int              _cnt;
 *     char             *_base;
 *     char             _flag;
 *     char             _file;
 *     int              _bsize;
 *   }
 *                      FILE;
 */
FILE                    _iob[_NFILE] =
{
    { NULL, NULL, _buf0, _IOREAD, 0, STDSIZ },
    { _buf1, STDSIZ, _buf1, _IOWRT, 1, STDSIZ },
};

typedef struct file2
{
    char  _flag2;
    char  _charbuf;
    int   _bufsiz;
    int   __tmpnum;
    char  _padding[2];              /* pad out to size of FILE structure */
}
          FILE2;

FILE2                   _iob2[_NFILE] =
{
    {0x01, '\0', STDSIZ        },
    {0x00, '\0', 0             }
};

#if (_MSC_VER >= 700)

// 23-Jun-1993 HV Kill the near keyword to make the compiler happy
#define near

/* pointer to end of descriptors */
FILE * near       _lastiob = &_iob[ _NFILE -1];
#endif

/*
 *  LOCAL FUNCTION PROTOTYPES
 */



int  cdecl               _filbuf(f)
REGISTER FILE            *f;
{
    if((f->_cnt = _read(f->_file,f->_base,f->_bsize)) <= 0)
    {
        if(!f->_cnt) f->_flag |= _IOEOF;
        else f->_flag |= _IOERR;
        return(EOF);
    }
    f->_ptr = f->_base;
    --f->_cnt;
    return((int) *f->_ptr++ & 0xff);
}

/* Just like _filbuf but don't return 1st char */

void  cdecl              _xfilbuf(f)
REGISTER FILE            *f;
{
    if((f->_cnt = _read(f->_file,f->_base,f->_bsize)) <= 0)
    {
        if(!f->_cnt) f->_flag |= _IOEOF;
        else f->_flag |= _IOERR;
    }
    f->_ptr = f->_base;
}

int  cdecl              _flsbuf(c,f)
unsigned                c;
REGISTER FILE           *f;
{
    unsigned            b;

    if(f->_flag & _IONBF)
    {
        b = c;
        if(_write(f->_file,&b,1) != 1)
        {
            f->_flag |= _IOERR;
            return(EOF);
        }
        f->_cnt = 0;
        return((int) c);
    }
    f->_cnt = f->_bsize - 1;
    if(_write(f->_file,f->_base,f->_bsize) != f->_bsize)
    {
        f->_flag |= _IOERR;
        return(EOF);
    }
    f->_ptr = f->_base;
    *f->_ptr++ = (char) c;
    return((int) c);
}

#if (_MSC_VER >= 700)
int  cdecl               _flush(f)
REGISTER FILE            *f;
{
    return(fflush(f));
}
#endif



int  cdecl               fflush(f)
REGISTER FILE            *f;
{
    REGISTER int        i;

    if(f->_flag & _IONBF) return(0);
    if(f->_flag & _IOWRT)
    {
        i = f->_bsize - f->_cnt;
        f->_cnt = f->_bsize;
        if(i && _write(f->_file,f->_base,i) != i)
        {
            f->_flag |= _IOERR;
            return(EOF);
        }
        f->_ptr = f->_base;
        return(0);
    }
    if(f->_flag & _IOREAD)
    {
        f->_cnt = 0;
        return(0);
    }
    return(EOF);
}

int  cdecl              fclose(f)
REGISTER FILE           *f;
{
    int                 rc;             /* Return code from close() */

    if(!(f->_flag & _IOPEN))
        return(EOF);
    fflush(f);
    if(f->_file > 2)
    {
        rc = _close(f->_file);
        /* Free the file stream pointer regardless of close() return
         * value, since code elsewhere may be intentionally calling
         * fclose() on a file whose handle has already been closed.
         */
        f->_flag = 0;
        ++cffree;
        return(rc);
    }
    return(0);
}

long  cdecl             ftell(f)
REGISTER FILE           *f;
{
    if(f->_flag & _IONBF) return(_lseek(f->_file,0L,1));
    if(f->_flag & _IOREAD) return(_lseek(f->_file,0L,1) - f->_cnt);
    if(f->_flag & _IOWRT) return(_lseek(f->_file,0L,1) + f->_bsize - f->_cnt);
    return(-1L);
}

int  cdecl              fseek(f,lfa,mode)
REGISTER FILE           *f;
long                    lfa;
int                     mode;
{
    REGISTER int        ilfa;

    f->_flag &= ~_IOEOF;
    if(f->_flag & _IONBF)
    {
        if(_lseek(f->_file,lfa,mode) != -1L) return(0);
        f->_flag |= _IOERR;
        return(EOF);
    }
    if(mode == 1)
    {
        if(f->_flag & _IOREAD)
        {
            if(((long) f->_cnt > lfa && lfa >= 0) ||
            (lfa < 0 && (long)(f->_base - f->_ptr) <= lfa))
            {                           /* If we won't go beyond the buffer */
                ilfa = (int) lfa;
                f->_cnt -= ilfa;
                f->_ptr += ilfa;
                return(0);
            }
            lfa -= f->_cnt;
        }
    }
    if(fflush(f)) return(EOF);
    if (mode != 2 && (f->_flag & _IOREAD))
    {
        /*
         * If absolute mode, or relative mode AND forward, seek to the
         * est preceding 512-byte boundary to optimize disk I/O.
         * It could be done for backward relative seeks as well, but we
         * would have to check whether the current file pointer (FP) is
         * on a 512-byte boundary.  If FP were not on a 512-byte boundary,
         * we might attempt to seek before the beginning of the file.
         * (Example:  FP = 0x2445, destination address = 0x0010, lfa = -0x2435,
         * mode = 1.  Rounding of lfa to 512-boundary yields -0x2600
         * which is bogus.)  FP will usually not be on a 512 boundary
         * at the end of file, for example.  Solution is to keep track of
         * current FP.  This is not worth the effort, especially since
         * seeks are rare because of the extended dictionary.
         * Use "lfa >= 0" as test, since if mode is 0 this will always be
         * true, and it also filters out backward relative seeks.
         */
        if(lfa >= 0)
        {
            /*
             * Optimization:  eliminate relative seeks of 0.
             */
            if(mode == 0 || lfa & ~0x1ff)
                if (_lseek(f->_file, lfa & ~0x1ff, mode) == -1L)
                {
                    f->_flag |= _IOERR;
                    return(EOF);
                }
            _xfilbuf(f);
            f->_cnt -= lfa & 0x1ff;     /* adjust _iobuf fields */
            f->_ptr += lfa & 0x1ff;
            return(0);
        }
    }
    if(_lseek(f->_file,lfa,mode) == -1L)
    {
        f->_flag |= _IOERR;
        return(EOF);
    }
    return(0);
}

int  cdecl              fgetc(f)
REGISTER FILE           *f;
{
    return(getc(f));
}

int  cdecl              fputc(c,f)
unsigned                c;
REGISTER FILE           *f;
{
    unsigned            b;

    if(f->_flag & _IONBF)
    {
        b = c;
        if(_write(f->_file,&b,1) == 1) return((int) c);
        f->_flag |= _IOERR;
        return(EOF);
    }
    return(putc(c,f));
}

int  cdecl               fputs(s,f)
REGISTER char            *s;
REGISTER FILE            *f;
{
    int         i;

    if(f->_flag & _IONBF)
    {
        i = strlen(s);
        if(_write(f->_file,s,i) == i) return(0);
        f->_flag |= _IOERR;
        return(EOF);
    }
    for(; *s; ++s)
        if(putc(*s,f) == EOF) return(EOF);
    return(0);
}

int  cdecl              fread(pobj,cbobj,nobj,f)
char                    *pobj;
unsigned                cbobj;
unsigned                nobj;
FILE                    *f;
{
    REGISTER int      i;        /* # bytes left to read */
    REGISTER unsigned j;        /* # bytes to transfer to buffer */

    // special case for one block -- try to avoid all this junk
    if (cbobj == 1 && nobj <= (unsigned)f->_cnt)
    {
        memcpy(pobj, f->_ptr, nobj);
        f->_cnt -= nobj;
        f->_ptr += nobj;
        return nobj;
    }

    i = nobj*cbobj;             /* Initial request ==> bytes */
    do
    {
        j = (i <= f->_cnt)? i: f->_cnt; /* Determine how much we can move */
        memcpy( pobj,f->_ptr,j);          /* Move it */
        f->_cnt -= j;                   /* Update file count */
        f->_ptr += j;                   /* Update file pointer */
        i -= j;                         /* Update request count */
        pobj += j;                      /* Update buffer pointer */
        if (i && !f->_cnt) _xfilbuf(f); /* Fill buffer if necessary */
    } while (i && !(f->_flag & (_IOEOF|_IOERR)));
    return(nobj - i/cbobj);
}

/*
 *  fwrite : standard library routine
 */
int  cdecl              fwrite(pobj,cbobj,nobj,f)

char                    *pobj;          /* Pointer to buffer */
int                     cbobj;          /* # bytes per object */
int                     nobj;           /* # objects */
register FILE           *f;             /* File stream */
{
    register int        cb;             /* # bytes remaining to write */


    /* Check for error initially so we don't trash data unnecessarily.  */
    if(ferror(f))
        return(0);

    /* Initialize count of bytes remaining to write.  */
    cb = nobj * cbobj;

    if (cb > f->_cnt) // doesn't fit -- must flush
        if (fflush(f))
            return 0;

    if (cb > f->_cnt) // bigger than the buffer... don't bother copying
        {
        if (_write(f->_file, pobj, cb) != cb)
            return 0;
        }
    else
        {
        memcpy(f->_ptr, pobj, cb);
        f->_cnt -= cb;
        f->_ptr += cb;
        }

    return nobj;
}


int  cdecl              ungetc(c,f)
int                     c;
FILE                    *f;
{
    if(!(f->_flag & _IONBF) && f->_cnt < f->_bsize && c != EOF)
    {
        ++f->_cnt;
        *--f->_ptr = (char) c;
        return(c);
    }
    return(EOF);
}


void cdecl              flushall ()
{
    FlsStdio();
}


#if (_MSC_VER >= 700)
void cdecl              _flushall ()
{
    FlsStdio();
}
#endif

void  cdecl             FlsStdio()
{
    FILE                *p;

    for(p = _iob; p < &_iob[_NSTD]; p++)
        if(p->_flag & _IOPEN) fclose(p);
}

/*
 *  makestream
 *
 *  Makes a file stream structure for a possibly already-opened file.
 *  Does common work for fopen, fdopen.
 *  If name parameter is NULL, then file has been opened, else use the
 *  name.
 *  RETURNS     pointer to stream or NULL.
 */

LOCAL FILE *  NEAR cdecl makestream(mode,name,fh)
char                     *mode;
char                     *name;
int                      fh;
{
    REGISTER int         i;
    REGISTER FILE        *f;
    int                  openmode;
    int                  iOpenRet;

    if(!cffree--)
    {
        cffree = 0;
        return(NULL);
    }
    for(i = _NSTD; _iob[i]._flag & _IOPEN; ++i);
    f = &_iob[i];
    f->_base = NULL;
    f->_bsize = 0;
    f->_flag = _IONBF;
    if(name == NULL)
        f->_file = (char) fh;
    if(*mode == 'r')
    {
        openmode = O_RDONLY;
        if(mode[1] == 't')
            openmode |= O_TEXT;
        else if(mode[1] == 'b')
            openmode |= O_BINARY;


        if(name != NULL)
        {
            iOpenRet = _open(name,openmode);
            if (iOpenRet == -1)
            {
                ++cffree;
                return(NULL);
            }
            else
            {
                f->_file = (char) iOpenRet;
            }
        }
        f->_cnt = 0;
        f->_flag |= _IOREAD;
        return(f);
    }
    f->_cnt = f->_bsize;
    f->_ptr = f->_base;
    openmode = O_CREAT | O_TRUNC | O_WRONLY;
    if(mode[1] == 't')
        openmode |= O_TEXT;
    else if(mode[1] == 'b')
        openmode |= O_BINARY;


        if(name != NULL)
        {
            iOpenRet = _open(name,openmode, 0600);
            if (iOpenRet == -1)
            {
                ++cffree;
                return(NULL);
            }
            else
            {
                f->_file = (char) iOpenRet;
            }
        }

    f->_flag |= _IOWRT;
    return(f);
}

/*
 *  fopen : (standard library routine)
 *
 *  WARNING:  This is a LIMITED version of fopen().  Only "r" and
 *  "w" modes are supported.
 */

FILE *  cdecl           fopen(name,mode)
char                    *name;
char                    *mode;
{
    return(makestream(mode,name,0));
}

/*
 *  fdopen : (standard library routine)
 *
 *  WARNING:  This is a LIMITED version of fdopen().  Only "r" and
 *  "w" modes are supported.
 */

FILE *  cdecl           fdopen(fh,mode)
int                     fh;
char                    *mode;
{
    return(makestream(mode,NULL,fh));
}

/*
 *  setvbuf : standard library routine
 *
 *  WARNING:  This is a LIMITED version of setvbuf().  Only
 *  type _IOFBF is supported.
 */
int  cdecl              setvbuf (fh, buf, type, size)
FILE                    *fh;
char                    *buf;
int                     type;
int                     size;
{
    if(fflush(fh) || type != _IOFBF)
        return(EOF);
    fh->_base = buf;
    fh->_flag &= ~_IONBF;
    fh->_bsize = size;
    if(fh->_flag & _IOWRT)
    {
        fh->_cnt = size;
        fh->_ptr = buf;
    }
    return(0);
}

#endif

int
__cdecl
printf(char *fmt, ...)
{
    va_list marker;
    int ret;

    va_start(marker, fmt);
    ret = vfprintf(stdout, fmt, marker);
    fflush(stdout);
    va_end(marker);
    return ret;
}

//
// DLH Can't use fprintf or vfprintf from MSVCRT.DLL, since the FILE structure
// is too different.
//

int cdecl fprintf(struct file *f, const char *fmt, ...)
{
    va_list marker;
    int ret;

    va_start(marker, fmt);
    ret = vfprintf(f, fmt, marker);
    fflush(f);
    va_end(marker);
    return ret;
}

int  cdecl vfprintf(struct file *f, const char *fmt, va_list pArgs)
{
    int cb;
    static char szBuf[4096];

    cb = vsprintf(szBuf, fmt, pArgs);

    fwrite(szBuf, 1, cb, f);

    return cb;
}