fsdos.c

Go to the documentation of this file.

/****************************************************************************************/
/*  FSDOS.C                                                                             */
/*                                                                                      */
/*  Author: Eli Boling                                                                  */
/*  Description: DOS file system implementation                                         */
/*                                                                                      */
/*  The contents of this file are subject to the Genesis3D Public License               */
/*  Version 1.01 (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.genesis3d.com                                                            */
/*                                                                                      */
/*  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 Genesis3D, released March 25, 1999.                            */
/*Genesis3D Version 1.1 released November 15, 1999                            */
/*  Copyright (C) 1999 WildTangent, Inc. All Rights Reserved           */
/*                                                                                      */
/****************************************************************************************/
#define WIN32_LEAN_AND_MEAN
#include        <windows.h>

#include        <stdio.h>
#include        <stdlib.h>
#include        <string.h>
#include        <assert.h>

#include        "basetype.h"
#include        "ram.h"

#include        "vfile.h"
#include        "vfile._h"

#include        "fsdos.h"

//      "DF01"
#define DOSFILE_SIGNATURE       0x31304644

//      "DF02"
#define DOSFINDER_SIGNATURE     0x32304644

#define CHECK_HANDLE(H) assert(H);assert(H->Signature == DOSFILE_SIGNATURE);
#define CHECK_FINDER(F) assert(F);assert(F->Signature == DOSFINDER_SIGNATURE);

typedef struct  DosFile
{
        unsigned int    Signature;
        HANDLE                  FileHandle;
        char *                  FullPath;
        const char *    Name;
        geBoolean               IsDirectory;
}       DosFile;

typedef struct  DosFinder
{
        unsigned int    Signature;
        HANDLE                  FindHandle;
        WIN32_FIND_DATA FindData;
        geBoolean               FirstStillCached;
        int                             OffsetToName;
}       DosFinder;

static  geBoolean       BuildFileName(
        const DosFile * File,
        const char *    Name,
        char *                  Buff,
        char **                 NamePtr,
        int                     MaxLen)
{
        int             DirLength;
        int             NameLength;

        if ( ! Name )
                return GE_FALSE;

        if      (File)
        {
                if      (File->IsDirectory == GE_FALSE)
                        return GE_FALSE;

                assert(File->FullPath);
                DirLength = strlen(File->FullPath);

                if      (DirLength > MaxLen)
                        return GE_FALSE;

                memcpy(Buff, File->FullPath, DirLength);
        }
        else
        {
                DirLength = 0;
        }

        NameLength = strlen(Name);
        if      (DirLength + NameLength + 2 > MaxLen || ! Buff )
                return GE_FALSE;

        if      (DirLength != 0)
        {
                Buff[DirLength] = '\\';
                memcpy(Buff + DirLength + 1, Name, NameLength + 1);
                if      (NamePtr)
                        *NamePtr = Buff + DirLength + 1;
        }
        else
        {
                memcpy(Buff, Name, NameLength + 1);
                if      (NamePtr)
                        *NamePtr = Buff;

                // Special case: no directory, no file name.  We meant something like ".\"
                if      (!*Buff)
                {
                        strcpy (Buff, ".\\");
                }
        }

        return GE_TRUE;
}

static  void *  GENESISCC FSDos_FinderCreate(
        geVFile *                       FS,
        void *                  Handle,
        const char *    FileSpec)
{
        DosFinder *             Finder;
        DosFile *               File;
        char *                  NamePtr;
        char                    Buff[_MAX_PATH];

        assert(FileSpec != NULL);

        File = Handle;

        CHECK_HANDLE(File);

        Finder = geRam_Allocate(sizeof(*Finder));
        if      (!Finder)
                return NULL;

        memset(Finder, 0, sizeof(*Finder));

        if      (BuildFileName(File, FileSpec, Buff, &NamePtr, sizeof(Buff)) == GE_FALSE)
        {
                geRam_Free(Finder);
                return NULL;
        }

        Finder->OffsetToName = NamePtr - Buff;

        Finder->FindHandle = FindFirstFile(Buff, &Finder->FindData);

        Finder->FirstStillCached = GE_TRUE;

        Finder->Signature = DOSFINDER_SIGNATURE;
        return (void *)Finder;
}

static  geBoolean       GENESISCC FSDos_FinderGetNextFile(void *Handle)
{
        DosFinder *     Finder;

        Finder = Handle;

        CHECK_FINDER(Finder);

        if      (Finder->FindHandle == INVALID_HANDLE_VALUE)
                return GE_FALSE;

        if      (Finder->FirstStillCached == GE_TRUE)
        {
                Finder->FirstStillCached = GE_FALSE;

                if      (Finder->FindData.cFileName[0] != '.')
                        return GE_TRUE;
        }
        
        while   (FindNextFile(Finder->FindHandle, &Finder->FindData) == TRUE)
        {
                if      (Finder->FindData.cFileName[0] != '.')
                        return GE_TRUE;
        }

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSDos_FinderGetProperties(void *Handle, geVFile_Properties *Props)
{
        DosFinder *                     Finder;
        geVFile_Attributes      Attribs;
        int                                     Length;

        assert(Props);

        Finder = Handle;

        CHECK_FINDER(Finder);

        if      (Finder->FindHandle == INVALID_HANDLE_VALUE)
                return GE_FALSE;

        Attribs = 0;
        if      (Finder->FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                Attribs |= GE_VFILE_ATTRIB_DIRECTORY;
        if      (Finder->FindData.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
                Attribs |= GE_VFILE_ATTRIB_READONLY;

        Props->Time.Time1 = Finder->FindData.ftLastWriteTime.dwLowDateTime;
        Props->Time.Time2 = Finder->FindData.ftLastWriteTime.dwHighDateTime;

        Props->AttributeFlags = Attribs;
        Props->Size = Finder->FindData.nFileSizeLow;
        Props->Hints.HintData = NULL;
        Props->Hints.HintDataLength = 0;

        Length = strlen(Finder->FindData.cFileName);
        if      (Length > sizeof(Props->Name) - 1)
                return GE_FALSE;
        memcpy(Props->Name, Finder->FindData.cFileName, Length + 1);

        return GE_TRUE;
}

static  void GENESISCC FSDos_FinderDestroy(void *Handle)
{
        DosFinder *     Finder;

        Finder = Handle;

        CHECK_FINDER(Finder);

        if      (Finder->FindHandle != INVALID_HANDLE_VALUE)
                FindClose(Finder->FindHandle);

        Finder->Signature = 0;
        geRam_Free(Finder);
}

// Terrible function.  It mutated, and now it modifies its argument.
static  geBoolean       IsRootDirectory(char *Path)
{
        int             SlashCount;

        // Drive letter test
        if      (Path[1] == ':' && Path[2] == '\\' && Path[3] == '\0')
        {
                Path[2] = '\0';
                return GE_TRUE;
        }

        // Now UNC path test
        SlashCount = 0;
        if      (Path[0] == '\\' && Path[1] == '\\')
        {
                Path += 2;
                while   (*Path)
                {
                        if      (*Path++ == '\\')
                                SlashCount++;
                }
        }

        if      (SlashCount == 1)
                return GE_TRUE;

        return GE_FALSE;
}

static  void *  GENESISCC FSDos_Open(
        geVFile *               FS,
        void *                  Handle,
        const char *    Name,
        void *                  Context,
        unsigned int    OpenModeFlags)
{
        DosFile *       DosFS;
        DosFile *       NewFile;
        char            Buff[_MAX_PATH];
        int                     Length;
        char *          NamePtr;

        DosFS = Handle;

        if      (DosFS && DosFS->IsDirectory != GE_TRUE)
                return NULL;

        NewFile = geRam_Allocate(sizeof(*NewFile));
        if      (!NewFile)
                return NewFile;

        memset(NewFile, 0, sizeof(*NewFile));

        if      (BuildFileName(DosFS, Name, Buff, &NamePtr, sizeof(Buff)) == GE_FALSE)
                goto fail;

        Length = strlen(Buff);
        NewFile->FullPath = geRam_Allocate(Length + 1);
        if      (!NewFile->FullPath)
                goto fail;

        NewFile->Name = NewFile->FullPath + (NamePtr - &Buff[0]);

        memcpy(NewFile->FullPath, Buff, Length + 1);

        if      (OpenModeFlags & GE_VFILE_OPEN_DIRECTORY)
        {
                WIN32_FIND_DATA FileInfo;
                HANDLE                  FindHandle;
                geBoolean               IsDirectory;

                assert(!DosFS || DosFS->IsDirectory == GE_TRUE);

                memset(&FileInfo, 0, sizeof(FileInfo));
                FindHandle = FindFirstFile(NewFile->FullPath, &FileInfo);
                if      (FindHandle != INVALID_HANDLE_VALUE &&
                         FileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                {
                        IsDirectory = GE_TRUE;
                }
                else
                {
                        IsDirectory = IsRootDirectory(NewFile->FullPath);
                }

                FindClose (FindHandle);

                if      (OpenModeFlags & GE_VFILE_OPEN_CREATE)
                {
                        if      (IsDirectory == GE_TRUE)
                                goto fail;

                        if      (CreateDirectory(NewFile->FullPath, NULL) == FALSE)
                                goto fail;
                }
                else
                {
                        if      (IsDirectory != GE_TRUE)
                                goto fail;
                }

                NewFile->IsDirectory = GE_TRUE;
                NewFile->FileHandle = INVALID_HANDLE_VALUE;
        }
        else
        {
                DWORD                   ShareMode=0;
                DWORD                   CreationMode;
                DWORD                   Access=0;
                DWORD                   LastError;

                CreationMode = OPEN_EXISTING;

                switch  (OpenModeFlags & (GE_VFILE_OPEN_READONLY |
                                                                  GE_VFILE_OPEN_UPDATE   |
                                                                  GE_VFILE_OPEN_CREATE))
                {
                case    GE_VFILE_OPEN_READONLY:
                        Access = GENERIC_READ;
                        ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
                        break;

                case    GE_VFILE_OPEN_CREATE:
                        CreationMode = CREATE_ALWAYS;
                        // Fall through

                case    GE_VFILE_OPEN_UPDATE:
                        Access = GENERIC_READ | GENERIC_WRITE;
                        ShareMode = FILE_SHARE_READ;
                        break;

                default:
                        assert(!"Illegal open mode flags");
                        break;
                }

                NewFile->FileHandle = CreateFile(NewFile->FullPath,
                                                                                 Access,
                                                                                 ShareMode,
                                                                                 NULL,
                                                                                 CreationMode,
                                                                                 0,
                                                                                 NULL);
                if      (NewFile->FileHandle == INVALID_HANDLE_VALUE)
                        {
                                LastError = GetLastError();
                                goto fail;
                        }
        }

        NewFile->Signature = DOSFILE_SIGNATURE;

        return (void *)NewFile;

fail:
        if      (NewFile->FullPath)
                geRam_Free(NewFile->FullPath);
        geRam_Free(NewFile);
        return NULL;
}

static  void *  GENESISCC FSDos_OpenNewSystem(
        geVFile *                       FS,
        const char *    Name,
        void *                  Context,
        unsigned int    OpenModeFlags)
{
        return FSDos_Open(FS, NULL, Name, Context, OpenModeFlags);
}

static  geBoolean       GENESISCC FSDos_UpdateContext(
        geVFile *               FS,
        void *                  Handle,
        void *                  Context,
        int                     ContextSize)
{
        return GE_FALSE;
}

static  void    GENESISCC FSDos_Close(void *Handle)
{
        DosFile *       File;
        
        File = Handle;
        
        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_FALSE)
        {
                assert(File->FileHandle != INVALID_HANDLE_VALUE);

                CloseHandle(File->FileHandle);
        }
        
        assert(File->FullPath);
        File->Signature = 0;
        geRam_Free(File->FullPath);
        geRam_Free(File);
}

static  geBoolean       GENESISCC FSDos_GetS(void *Handle, void *Buff, int MaxLen)
{
        DosFile *       File;
        DWORD           BytesRead;
        BOOL            Result;
        char *          p;
        char *          End;

        assert(Buff);
        assert(MaxLen != 0);

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->FileHandle != INVALID_HANDLE_VALUE);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

        Result = ReadFile(File->FileHandle, Buff, MaxLen - 1, &BytesRead, NULL);
        if      (BytesRead == 0)
        {
#if 0
                if      (Result == FALSE)
                        return GE_FALSE;
                
                // The Win32 API is vague about this, so we're being weird with the asserts
                assert(Result != TRUE);
#endif
                return GE_FALSE;
        }

        End = (char *)Buff + BytesRead;
        p = Buff;
        while   (p < End)
        {
                /*
                  This code will terminate a line on one of three conditions:
                        \r      Character changed to \n, next char set to 0
                        \n      Next char set to 0
                        \r\n    First \r changed to \n.  \n changed to 0.
                */
                if      (*p == '\r')
                {
                        int Skip = 0;
                        
                        *p = '\n';              // set end of line
                        p++;                    // and skip to next char
                        // If the next char is a newline, then skip it too  (\r\n case)
                        if (*p == '\n')
                        {
                                Skip = 1;
                        }
                        *p = '\0';
                        // Set the file pointer back a bit since we probably overran
                        SetFilePointer(File->FileHandle, -(int)(BytesRead - ((p + Skip) - (char *)Buff)), NULL, FILE_CURRENT); 
                        assert(p - (char *)Buff <= MaxLen);
                        return GE_TRUE;
                }
                else if (*p == '\n')
                {
                        // Set the file pointer back a bit since we probably overran
                        p++;
                        SetFilePointer(File->FileHandle, -(int)(BytesRead - (p - (char *)Buff)), NULL, FILE_CURRENT); 
                        *p = '\0';
                        assert(p - (char *)Buff <= MaxLen);
                        return GE_TRUE;
                }
                p++;
        }

        return GE_FALSE;
}


static  geBoolean       GENESISCC FSDos_Read(void *Handle, void *Buff, int Count)
{
        DosFile *       File;
        DWORD           BytesRead;

        assert(Buff);
        assert(Count != 0);

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

#ifdef  ELIDEBUG
{
        FILE *  fp;
        long    Position;

        Position = SetFilePointer(File->FileHandle, 0, NULL, FILE_CURRENT);
        fp = fopen("c:\\vfs.eli", "ab+");
        fprintf(fp, "FSDos_Read: %-8d bytes @ %-8d\r\n", Count, Position);
        fclose(fp);
}
#endif

        if      (ReadFile(File->FileHandle, Buff, Count, &BytesRead, NULL) == FALSE)
                return GE_FALSE;

        if      (BytesRead == 0)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_Write(void *Handle, const void *Buff, int Count)
{
        DosFile *       File;
        DWORD           BytesWritten;

        assert(Buff);
        assert(Count != 0);

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

#ifdef  ELIDEBUG
{
        FILE *  fp;
        long    Position;

        Position = SetFilePointer(File->FileHandle, 0, NULL, FILE_CURRENT);
        fp = fopen("c:\\vfs.eli", "ab+");
        fprintf(fp, "FSDos_Write: %-8d bytes @ %-8d\r\n", Count, Position);
        fclose(fp);
}
#endif

        if      (WriteFile(File->FileHandle, Buff, Count, &BytesWritten, NULL) == FALSE)
                return GE_FALSE;

        if      ((int)BytesWritten != Count)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_Seek(void *Handle, int Where, geVFile_Whence Whence)
{
        int                     RTLWhence=0;
        DosFile *       File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

        switch  (Whence)
        {
        case    GE_VFILE_SEEKCUR:
                RTLWhence = FILE_CURRENT;
                break;

        case    GE_VFILE_SEEKEND:
                RTLWhence = FILE_END;
                break;

        case    GE_VFILE_SEEKSET:
                RTLWhence = FILE_BEGIN;
                break;
        default:
                assert(!"Unknown seek kind");
        }

        if      (SetFilePointer(File->FileHandle, Where, NULL, RTLWhence) == 0xffffffff)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_EOF(const void *Handle)
{
        const DosFile * File;
        DWORD                   CurPos;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

        assert(File->FileHandle != INVALID_HANDLE_VALUE);

        CurPos = SetFilePointer(File->FileHandle, 0, NULL, FILE_CURRENT);
        assert(CurPos != 0xffffffff);

        if      (CurPos == GetFileSize(File->FileHandle, NULL))
                return GE_TRUE;

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSDos_Tell(const void *Handle, long *Position)
{
        const DosFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

        assert(File->FileHandle != INVALID_HANDLE_VALUE);

        *Position = SetFilePointer(File->FileHandle, 0, NULL, FILE_CURRENT);
        if      (*Position == -1L)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_Size(const void *Handle, long *Size)
{
        const DosFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

        assert(File->FileHandle != INVALID_HANDLE_VALUE);

        *Size = GetFileSize(File->FileHandle, NULL);
        if      (*Size != (long)0xffffffff)
                return GE_TRUE;

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSDos_GetProperties(const void *Handle, geVFile_Properties *Properties)
{
        const DosFile *                         File;
        geVFile_Attributes                      Attribs;
        BY_HANDLE_FILE_INFORMATION      Info;
        int                                                     Length;

        assert(Properties);

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_TRUE)
        {
                memset(Properties, 0, sizeof(*Properties));
                Properties->AttributeFlags = FILE_ATTRIBUTE_DIRECTORY;
#pragma message ("FSDos_GetProperties: Time support is not there for directories")
        }
        else
        {
                assert(File->FileHandle != INVALID_HANDLE_VALUE);
        
                if      (GetFileInformationByHandle(File->FileHandle, &Info) == FALSE)
                        return GE_FALSE;
        
                Attribs = 0;
                if      (Info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                        Attribs |= GE_VFILE_ATTRIB_DIRECTORY;
                if      (Info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
                        Attribs |= GE_VFILE_ATTRIB_READONLY;
        
                Properties->Time.Time1 = Info.ftLastWriteTime.dwLowDateTime;
                Properties->Time.Time2 = Info.ftLastWriteTime.dwHighDateTime;
        
                Properties->AttributeFlags               = Attribs;
                Properties->Size                                 = Info.nFileSizeLow;
                Properties->Hints.HintData               = NULL;
                Properties->Hints.HintDataLength = 0;
        }

        Length = strlen(File->Name) + 1;
        if      (Length > sizeof(Properties->Name))
                return GE_FALSE;
        memcpy(Properties->Name, File->Name, Length);

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_SetSize(void *Handle, long size)
{
        DosFile *       File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->IsDirectory == GE_FALSE)
        {
                assert(File->FileHandle != INVALID_HANDLE_VALUE);
        
                if      (SetFilePointer(File->FileHandle, 0, NULL, FILE_END) == 0xffffffff)
                        return GE_FALSE;
        
                if      (SetEndOfFile(File->FileHandle) == FALSE)
                        return GE_FALSE;
        }

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSDos_SetAttributes(void *Handle, geVFile_Attributes Attributes)
{
        DosFile *       File;
        DWORD           Win32Attributes;

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->FileHandle != INVALID_HANDLE_VALUE);

        if      (File->IsDirectory == GE_TRUE)
                return GE_FALSE;

        if      (Attributes & GE_VFILE_ATTRIB_READONLY)
                Win32Attributes = FILE_ATTRIBUTE_READONLY;
        else
                Win32Attributes = FILE_ATTRIBUTE_NORMAL;

        if      (SetFileAttributes(File->FullPath, Win32Attributes) == FALSE)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_SetTime(void *Handle, const geVFile_Time *Time)
{
        DosFile *       File;
        FILETIME        Win32Time;

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->FileHandle != INVALID_HANDLE_VALUE);

        Win32Time.dwLowDateTime  = Time->Time1;
        Win32Time.dwHighDateTime = Time->Time2;
        if      (SetFileTime(File->FileHandle, &Win32Time, &Win32Time, &Win32Time) == FALSE)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_SetHints(void *Handle, const geVFile_Hints *Hints)
{
        DosFile *       File;

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->FileHandle != INVALID_HANDLE_VALUE);

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSDos_FileExists(geVFile *FS, void *Handle, const char *Name)
{
        DosFile *       File;
        char            Buff[_MAX_PATH];

        File = Handle;

        if      (File && File->IsDirectory == GE_FALSE)
                return GE_FALSE;

        if      (BuildFileName(File, Name, Buff, NULL, sizeof(Buff)) == GE_FALSE)
                return GE_FALSE;

        if      (GetFileAttributes(Buff) == 0xffffffff)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_Disperse(
        geVFile *               FS,
        void *          Handle,
        const char *Directory,
        geBoolean       Recursive)
{
        return GE_FALSE;
}

static  geBoolean       GENESISCC FSDos_DeleteFile(geVFile *FS, void *Handle, const char *Name)
{
        DosFile *       File;
        char            Buff[_MAX_PATH];

        File = Handle;

        if      (File && File->IsDirectory == GE_FALSE)
                return GE_FALSE;

        if      (BuildFileName(File, Name, Buff, NULL, sizeof(Buff)) == GE_FALSE)
                return GE_FALSE;

        if      (DeleteFile(Buff) == FALSE)
                return GE_FALSE;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSDos_RenameFile(geVFile *FS, void *Handle, const char *Name, const char *NewName)
{
        DosFile *       File;
        char            Old[_MAX_PATH];
        char            New[_MAX_PATH];

        File = Handle;

        if      (File && File->IsDirectory == GE_FALSE)
                return GE_FALSE;

        if      (BuildFileName(File, Name, Old, NULL, sizeof(Old)) == GE_FALSE)
                return GE_FALSE;

        if      (BuildFileName(File, NewName, New, NULL, sizeof(New)) == GE_FALSE)
                return GE_FALSE;

        if      (MoveFile(Old, New) == FALSE)
                return GE_FALSE;

        return GE_TRUE;
}

static  geVFile_SystemAPIs      FSDos_APIs =
{
        FSDos_FinderCreate,
        FSDos_FinderGetNextFile,
        FSDos_FinderGetProperties,
        FSDos_FinderDestroy,

        FSDos_OpenNewSystem,
        FSDos_UpdateContext,
        FSDos_Open,
        FSDos_DeleteFile,
        FSDos_RenameFile,
        FSDos_FileExists,
        FSDos_Disperse,
        FSDos_Close,

        FSDos_GetS,
        FSDos_Read,
        FSDos_Write,
        FSDos_Seek,
        FSDos_EOF,
        FSDos_Tell,
        FSDos_Size,

        FSDos_GetProperties,

        FSDos_SetSize,
        FSDos_SetAttributes,
        FSDos_SetTime,
        FSDos_SetHints,
};

const geVFile_SystemAPIs *GENESISCC FSDos_GetAPIs(void)
{
        return &FSDos_APIs;
}

---