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