1 files changed, 305 insertions, 0 deletions
diff --git a/board/MAI/bios_emulator/scitech/src/pm/vxd/fileio.c b/board/MAI/bios_emulator/scitech/src/pm/vxd/fileio.c
new file mode 100644
index 0000000000..e2ff585839
--- /dev/null
+++ b/board/MAI/bios_emulator/scitech/src/pm/vxd/fileio.c
@@ -0,0 +1,305 @@
+/****************************************************************************
+*
+*                   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;
+}
+