board/MAI/bios_emulator/scitech/src/pm/vxd/fileio.c - uboot/windcharger - Git at Google

 /****************************************************************************
 *
 *                   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;
 }
	/****************************************************************************
	*
	* 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;
	}