/****************************************************************************
*
*                   SciTech OS Portability Manager Library
*
*  ========================================================================
*
*    The contents of this file are subject to the SciTech MGL Public
*    License Version 1.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.scitechsoft.com/mgl-license.txt
*
*    Software distributed under the License is distributed on an
*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
*    implied. See the License for the specific language governing
*    rights and limitations under the License.
*
*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
*
*    The Initial Developer of the Original Code is SciTech Software, Inc.
*    All Rights Reserved.
*
*  ========================================================================
*
* Language:     ANSI C
* Environment:  32-bit Windows VxD
*
* Description:  C library compatible I/O functions for use within a VxD.
*
****************************************************************************/

#include "pmapi.h"
#include "vxdfile.h"

/*------------------------ Main Code Implementation -----------------------*/

#define EOF -1

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C fopen function.
****************************************************************************/
FILE * fopen(
    const char *filename,
    const char *mode)
{
    FILE    *f = PM_malloc(sizeof(FILE));
    long    oldpos;

    if (f) {
	f->offset = 0;
	f->text = (mode[1] == 't' || mode[2] == 't');
	f->writemode = (mode[0] == 'w') || (mode[0] == 'a');
	if (initComplete) {
	    WORD    omode,error;
	    BYTE    action;

	    if (mode[0] == 'r') {
		omode = OPEN_ACCESS_READONLY | OPEN_SHARE_COMPATIBLE;
		action = ACTION_IFEXISTS_OPEN | ACTION_IFNOTEXISTS_FAIL;
		}
	    else if (mode[0] == 'w') {
		omode = OPEN_ACCESS_WRITEONLY | OPEN_SHARE_COMPATIBLE;
		action = ACTION_IFEXISTS_TRUNCATE | ACTION_IFNOTEXISTS_CREATE;
		}
	    else {
		omode = OPEN_ACCESS_READWRITE | OPEN_SHARE_COMPATIBLE;
		action = ACTION_IFEXISTS_OPEN | ACTION_IFNOTEXISTS_CREATE;
		}
	    f->handle = (int)R0_OpenCreateFile(false,(char*)filename,omode,ATTR_NORMAL,action,0,&error,&action);
	    if (f->handle == 0) {
		PM_free(f);
		return NULL;
		}
	    f->filesize = R0_GetFileSize((HANDLE)f->handle,&error);
	    if (mode[0] == 'a')
		fseek(f,0,2);
	    }
	else {
	    int oflag,pmode;

	    if (mode[0] == 'r') {
		pmode = _S_IREAD;
		oflag = _O_RDONLY;
		}
	    else if (mode[0] == 'w') {
		pmode = _S_IWRITE;
		oflag = _O_WRONLY | _O_CREAT | _O_TRUNC;
		}
	    else {
		pmode = _S_IWRITE;
		oflag = _O_RDWR | _O_CREAT | _O_APPEND;
		}
	    if (f->text)
		oflag |= _O_TEXT;
	    else
		oflag |= _O_BINARY;
	    if ((f->handle = i_open(filename,oflag,pmode)) == -1) {
		PM_free(f);
		return NULL;
		}
	    oldpos = i_lseek(f->handle,0,1);
	    f->filesize = i_lseek(f->handle,0,2);
	    i_lseek(f->handle,oldpos,0);
	    }
	}
    return f;
}

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C fread function. Note that the VxD file I/O
functions are layered on DOS, so can only read up to 64K at a time. Since
we are expected to handle much larger chunks than this, we handle larger
blocks automatically in here.
****************************************************************************/
size_t fread(
    void *ptr,
    size_t size,
    size_t n,
    FILE *f)
{
    char    *buf = ptr;
    WORD    error;
    int     bytes = size * n;
    int     readbytes,totalbytes = 0;

    while (bytes > 0x10000) {
	if (initComplete) {
	    readbytes  = R0_ReadFile(false,(HANDLE)f->handle,buf,0x8000,f->offset,&error);
	    readbytes += R0_ReadFile(false,(HANDLE)f->handle,buf+0x8000,0x8000,f->offset+0x8000,&error);
	    }
	else {
	    readbytes  = i_read(f->handle,buf,0x8000);
	    readbytes += i_read(f->handle,buf+0x8000,0x8000);
	    }
	totalbytes += readbytes;
	f->offset += readbytes;
	buf += 0x10000;
	bytes -= 0x10000;
	}
    if (bytes) {
	if (initComplete)
	    readbytes = R0_ReadFile(false,(HANDLE)f->handle,buf,bytes,f->offset,&error);
	else
	    readbytes = i_read(f->handle,buf,bytes);
	totalbytes += readbytes;
	f->offset += readbytes;
	}
    return totalbytes / size;
}

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C fwrite function. Note that the VxD file I/O
functions are layered on DOS, so can only read up to 64K at a time. Since
we are expected to handle much larger chunks than this, we handle larger
blocks automatically in here.
****************************************************************************/
size_t fwrite(
    const void *ptr,
    size_t size,
    size_t n,
    FILE *f)
{
    const char  *buf = ptr;
    WORD        error;
    int         bytes = size * n;
    int         writtenbytes,totalbytes = 0;

    if (!f->writemode)
	return 0;
    while (bytes > 0x10000) {
	if (initComplete) {
	    writtenbytes  = R0_WriteFile(false,(HANDLE)f->handle,buf,0x8000,f->offset,&error);
	    writtenbytes += R0_WriteFile(false,(HANDLE)f->handle,buf+0x8000,0x8000,f->offset+0x8000,&error);
	    }
	else {
	    writtenbytes  = i_write(f->handle,buf,0x8000);
	    writtenbytes += i_write(f->handle,buf+0x8000,0x8000);
	    }
	totalbytes += writtenbytes;
	f->offset += writtenbytes;
	buf += 0x10000;
	bytes -= 0x10000;
	}
    if (initComplete)
	writtenbytes = R0_WriteFile(false,(HANDLE)f->handle,buf,bytes,f->offset,&error);
    else
	writtenbytes = i_write(f->handle,buf,bytes);
    totalbytes += writtenbytes;
    f->offset += writtenbytes;
    if (f->offset > f->filesize)
	f->filesize = f->offset;
    return totalbytes / size;
}

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C fflush function.
****************************************************************************/
int fflush(
    FILE *f)
{
    /* Nothing to do since we are not doing buffered file I/O */
    (void)f;
    return 0;
}

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C fseek function.
****************************************************************************/
int fseek(
    FILE *f,
    long int offset,
    int whence)
{
    if (whence == 0)
	f->offset = offset;
    else if (whence == 1)
	f->offset += offset;
    else if (whence == 2)
	f->offset = f->filesize + offset;
    if (!initComplete)
	i_lseek(f->handle,f->offset,0);
    return 0;
}

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C ftell function.
****************************************************************************/
long ftell(
    FILE *f)
{
    return f->offset;
}

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C feof function.
****************************************************************************/
int feof(
    FILE *f)
{
    return (f->offset == f->filesize);
}

/****************************************************************************
REMARKS:
NT driver implementation of the ANSI C fgets function.
****************************************************************************/
char *fgets(
    char *s,
    int n,
    FILE *f)
{
    int     len;
    char    *cs;

    /* Read the entire buffer into memory (our functions are unbuffered!) */
    if ((len = fread(s,1,n,f)) == 0)
	return NULL;

    /* Search for '\n' or end of string */
    if (n > len)
	n = len;
    cs = s;
    while (--n > 0) {
	if (*cs == '\n')
	    break;
	cs++;
	}
    *cs = '\0';
    return s;
}

/****************************************************************************
REMARKS:
NT driver implementation of the ANSI C fputs function.
****************************************************************************/
int fputs(
    const char *s,
    FILE *f)
{
    return fwrite(s,1,strlen(s),f);
}

/****************************************************************************
REMARKS:
VxD implementation of the ANSI C fclose function.
****************************************************************************/
int fclose(
    FILE *f)
{
    WORD error;

    if (initComplete)
	R0_CloseFile((HANDLE)f->handle,&error);
    else
	i_close(f->handle);
    PM_free(f);
    return 0;
}