fsvfs.c

Go to the documentation of this file.

/****************************************************************************************/
/*  FSVFS.C                                                                             */
/*                                                                                      */
/*  Author: Eli Boling                                                                  */
/*  Description: Collection 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           */
/*                                                                                      */
/****************************************************************************************/
#include        <stdio.h>
#include        <stdlib.h>
#include        <string.h>
#include        <assert.h>

#include        "ram.h"

#include        "fsvfs.h"
#include        "dirtree.h"

//      "VF00"
#define VFSFILEHEADER_SIGNATURE 0x30304656
//      "CF00"
#define VCFSFILEHEADER_SIGNATURE        0x30304643

//      "VF01"
#define VFSFILE_SIGNATURE               0x31304656

//      "VF02"
#define VFSFINDER_SIGNATURE             0x32304656

#define HEADER_VERSION  0

typedef struct  VFSFileHeader
{
        unsigned int    Signature;
        unsigned short  Version;                        // Version number
        geBoolean               Dispersed;                      // Is this VFS dispersed?
        long                    DirectoryOffset;        // File offset to directory
        long                    DataLength;                     // Length of all file data, including VFS header
        long                    EndPosition;            // End Position in the RWOps file we were written to
}       VFSFileHeader;

// In the above structure, EndPosition should be the same as DataLength.  We use this for
// asserts.

typedef struct  VFSFile
{
        unsigned int    Signature;

        geVFile *               RWOps;                          // Parent file for read/write ops
        struct VFSFile *System;                         // If we're a child, we need a back pointer

        DirTree *               DirEntry;                       // Directory entry for this file
        DirTree *               Directory;                      // Directory information for the VFS

        long                    RWOpsStartPos;          // Starting position in the RWOps file
        long                    CurrentRelPos;          // Current file pointer (relative to our start)
        long                    Length;                         // Current file size
        char                    Mask;

        unsigned int    OpenModeFlags;

        // Things that are specific to the Root node
        long                    EndPosition;            // End position in the RWOps file if we're a system
        geBoolean               IsSystem;                       // Am I the owner of the Directory?
        long                    DataLength;                     // Current size of the aggregate including VFS header
        geBoolean               Dispersed;                      // Is this VFS dispersed?

}       VFSFile;

typedef struct  VFSFinder
{
        unsigned int            Signature;
        VFSFile *                       File;
        DirTree_Finder *        Finder;
        DirTree *                       LastFind;
}       VFSFinder;

#define CHECK_HANDLE(H) assert(H);assert(H->Signature == VFSFILE_SIGNATURE);
#define CHECK_FINDER(F) assert(F);assert(F->Signature == VFSFINDER_SIGNATURE);

static  void *  GENESISCC FSVFS_FinderCreate(
        geVFile *               FS,
        void *                  Handle,
        const char *    FileSpec)
{
        VFSFinder *             Finder;
        VFSFile *               File;

        assert(FileSpec != NULL);

        File = Handle;

        CHECK_HANDLE(File);

        if      (!File->Directory)
                return NULL;

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

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

        Finder->Signature = VFSFINDER_SIGNATURE;
        Finder->File      = File;
        Finder->Finder    = DirTree_CreateFinder(File->Directory, FileSpec);
        if      (!Finder->Finder)
        {
                geRam_Free(Finder);
                return NULL;
        }

        return (void *)Finder;
}

static  geBoolean       GENESISCC FSVFS_FinderGetNextFile(void *Handle)
{
        VFSFinder *     Finder;

        Finder = Handle;

        CHECK_FINDER(Finder);

        Finder->LastFind = DirTree_FinderGetNextFile(Finder->Finder);
        if      (Finder->LastFind)
                return GE_TRUE;

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSVFS_FinderGetProperties(void *Handle, geVFile_Properties *Properties)
{
        VFSFinder *             Finder;

        assert(Properties);

        Finder = Handle;

        CHECK_FINDER(Finder);

        if      (!Finder->LastFind)
                return GE_FALSE;

        DirTree_GetFileTime(Finder->LastFind, &Properties->Time);
        DirTree_GetFileAttributes(Finder->LastFind, &Properties->AttributeFlags);
        DirTree_GetFileSize(Finder->LastFind, &Properties->Size);
        DirTree_GetFileHints(Finder->LastFind, &Properties->Hints);
        return DirTree_GetName(Finder->LastFind, &Properties->Name[0], sizeof(Properties->Name));
}

static  void GENESISCC FSVFS_FinderDestroy(void *Handle)
{
        VFSFinder *     Finder;

        Finder = Handle;

        CHECK_FINDER(Finder);

        assert(Finder->Finder);

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

static  void *  GENESISCC FSVFS_Open(
        geVFile *               FS,
        void *                  Handle,
        const char *    Name,
        void *                  Dummy,
        unsigned int    OpenModeFlags)
{
        VFSFile *       Context;
        VFSFile *       NewFile;
        DirTree *       FileEntry;

        Context = Handle;

        CHECK_HANDLE(Context);

        assert(Name);

        if      (!Context->Directory)
                return NULL;

        /*
                Right now, we only support update operations to a VFS which is being
                created.  We can do create operations to a VFS which is being created,
                or which already exists.  We can also support directory open operations
                at anytime.
        */
        if      ((OpenModeFlags & GE_VFILE_OPEN_UPDATE)   &&
                 !(OpenModeFlags & GE_VFILE_OPEN_DIRECTORY) &&
                 !(OpenModeFlags & GE_VFILE_OPEN_CREATE) &&
                 !(Context->System->OpenModeFlags & GE_VFILE_OPEN_CREATE))
                return NULL;

        FileEntry = DirTree_FindExact(Context->Directory, Name);
        if      (OpenModeFlags & GE_VFILE_OPEN_CREATE)
        {
                if      (FileEntry)
                        return NULL;

                FileEntry = DirTree_AddFile(Context->Directory,
                                                                        Name,
                                                                        (OpenModeFlags & GE_VFILE_OPEN_DIRECTORY) ? GE_TRUE : GE_FALSE);
                if      (!FileEntry)
                        return NULL;
        }
        else
        {
                if      (!FileEntry)
                        return NULL;
        }

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

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

        NewFile->Signature        = VFSFILE_SIGNATURE;
        NewFile->DirEntry         = FileEntry;
        NewFile->RWOps            = Context->RWOps;
        NewFile->Dispersed        = GE_FALSE;
        NewFile->System           = Context->System;
        NewFile->Mask             = Context->Mask;

        // If we're a directory, make us a first class operator with the child
        if      (OpenModeFlags & GE_VFILE_OPEN_DIRECTORY)
        {
                NewFile->Directory = FileEntry;
        }
        else
        {
                if      (OpenModeFlags & GE_VFILE_OPEN_CREATE)
                {
                        NewFile->RWOpsStartPos = Context->System->DataLength +
                                                                         Context->System->RWOpsStartPos;
                }
                else
                {
                        DirTree_GetFileOffset(FileEntry, &NewFile->RWOpsStartPos);
                }
        }

        NewFile->OpenModeFlags = OpenModeFlags;

        if      (!(OpenModeFlags & GE_VFILE_OPEN_DIRECTORY))
        {
                if      (OpenModeFlags & GE_VFILE_OPEN_CREATE)
                {
                        DirTree_SetFileOffset(FileEntry, NewFile->RWOpsStartPos);
                }
                else
                {
                        assert(!(OpenModeFlags & GE_VFILE_OPEN_UPDATE));
                        DirTree_GetFileSize(FileEntry, &NewFile->Length);
                }
        }

        // Only a VFS opened with OpenNewSystem gets to be the owner
        NewFile->IsSystem = GE_FALSE;

        return (void *)NewFile;
}

static  void *  GENESISCC FSVFS_OpenNewSystem(
        geVFile *               RWOps,
        const char *    Name,
        void *                  Context,
        unsigned int    OpenModeFlags)
{
        VFSFile *       NewFS;
        long            RWOpsStartPos;
        char *TStr;
        char EString[256];
        char Mask;

        assert(RWOps != NULL);
        assert(Name == NULL);
        if(Context == NULL)
                Mask = 0;
        else
        {
                TStr = (char *)Context;
                strncpy(EString, TStr, 8);
                Mask = EString[0] & 0x01;
                Mask |= EString[7] & 0x02;
                Mask |= EString[1] & 0x04;
                Mask |= EString[6] & 0x08;
                Mask |= EString[2] & 0x10;
                Mask |= EString[5] & 0x20;
                Mask |= EString[3] & 0x40;
                Mask |= EString[4] & 0x80;

                //Mask = (EString[0]<<2) & 0xc0;
                //Mask |= EString[1] & 0x30;
                //Mask |= EString[2] & 0x0c;
                //Mask |= EString[3] & 0x03;
        }

        // All VFS are directories
        if      (!(OpenModeFlags & GE_VFILE_OPEN_DIRECTORY))
                return NULL;

        if      (geVFile_Tell(RWOps, &RWOpsStartPos) == GE_FALSE)
                return NULL;

        if      (!(OpenModeFlags & GE_VFILE_OPEN_CREATE))
        {
                VFSFileHeader   Header;
                long                    DirectoryStartPos;
                long                    DirectoryEndPos;

//#pragma message  ("FSVFS_OpenNewSystem: READ/WRITE opens not supported")

                if      (geVFile_Read(RWOps, &Header, sizeof(Header)) == GE_FALSE)
                        return NULL;

                if      (!((Header.Signature == VFSFILEHEADER_SIGNATURE) || (Header.Signature == VCFSFILEHEADER_SIGNATURE)))
                        return NULL;

                if      (Header.Version != HEADER_VERSION)
                        return NULL;

                if      (Header.Dispersed == GE_TRUE)
                {
                        assert(!"Not implemented");
                        return NULL;
                }

                // Go to the directory
                if      (geVFile_Seek(RWOps, Header.DirectoryOffset, GE_VFILE_SEEKSET) == GE_FALSE)
                        return NULL;

                // Remember where we started reading the directory
                if      (geVFile_Tell(RWOps, &DirectoryStartPos) == GE_FALSE)
                        return NULL;

                NewFS = geRam_Allocate(sizeof(*NewFS));
                if      (!NewFS)
                        return NewFS;
                memset(NewFS, 0, sizeof(*NewFS));

                NewFS->RWOps = RWOps;
                NewFS->RWOpsStartPos = RWOpsStartPos;
                NewFS->DataLength = Header.DataLength;
                NewFS->EndPosition = Header.EndPosition;
                NewFS->Mask     = Mask;

                // Read the directory
                NewFS->Directory = DirTree_CreateFromFile(RWOps);
                if      (!NewFS->Directory)
                {
                        geRam_Free(NewFS);
                        return NULL;
                }

                // Get the end position for paranoia checking
                if      (geVFile_Tell(RWOps, &DirectoryEndPos) == GE_FALSE)
                {
                        DirTree_Destroy(NewFS->Directory);
                        geRam_Free(NewFS);
                        return NULL;
                }
        }
        else
        {
                NewFS = geRam_Allocate(sizeof(*NewFS));
                if      (!NewFS)
                        return NewFS;
                memset(NewFS, 0, sizeof(*NewFS));

                NewFS->RWOps = RWOps;
                NewFS->RWOpsStartPos = RWOpsStartPos;
                NewFS->Directory = DirTree_Create();
                NewFS->DataLength = sizeof(VFSFileHeader);
                NewFS->Mask     = Mask;
        }

        NewFS->Signature         = VFSFILE_SIGNATURE;
        NewFS->IsSystem          = GE_TRUE;
        NewFS->System            = NewFS;
        NewFS->OpenModeFlags = OpenModeFlags;

        return NewFS;
}

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

static  void    GENESISCC FSVFS_Close(void *Handle)
{
        VFSFile *       File;

        File = Handle;
        
        CHECK_HANDLE(File);

        if      (File->Directory)
        {
                if      (File->IsSystem == GE_TRUE)
                {
                        // Hmmm.  We're the top level
                        assert(File == File->System);

                        if      (File->OpenModeFlags & (GE_VFILE_OPEN_CREATE | GE_VFILE_OPEN_UPDATE))
                        {
                                VFSFileHeader   Header;
                                long                    EndPosition;

                                // Have to update the directory
                                if      (geVFile_Seek(File->RWOps, File->RWOpsStartPos + File->DataLength, GE_VFILE_SEEKSET) == GE_FALSE)
                                {
                                        // What to do on failure?
                                        assert(!"Can't fail");
                                }
                                if      (DirTree_WriteToFile(File->Directory, File->RWOps) == GE_FALSE)
                                {
                                        // What to do on failure?
                                        assert(!"Can't fail");
                                }
                                geVFile_Tell(File->RWOps, &EndPosition);
                                if      (geVFile_Seek(File->RWOps, File->RWOpsStartPos, GE_VFILE_SEEKSET) == GE_FALSE)
                                {
                                        // What to do on failure?
                                        assert(!"Can't fail");
                                }
                                if(File->Mask==0)
                                        Header.Signature = VFSFILEHEADER_SIGNATURE;
                                else
                                        Header.Signature = VCFSFILEHEADER_SIGNATURE;
                                Header.Version = HEADER_VERSION;
                                Header.Dispersed = GE_FALSE;
                                Header.EndPosition = EndPosition;

                                Header.DirectoryOffset = File->RWOpsStartPos + File->DataLength;
                                Header.DataLength = File->DataLength;
                                if      (geVFile_Write(File->RWOps, &Header, sizeof(Header)) == GE_FALSE)
                                {
                                        // What to do on failure?
                                        assert(!"Can't fail");
                                }

                                // Make sure that we end up at the end of the RWOps file
                                geVFile_Seek(File->RWOps, EndPosition, GE_VFILE_SEEKSET);
                        }
                        else
                        {
                                // Have to make sure that we leave the file pointer at the end
                                // of our data in the RWOps file that we come from.

                                geVFile_Seek(File->RWOps, File->EndPosition, GE_VFILE_SEEKSET);
                        }

                        DirTree_Destroy(File->Directory);
                }
        }
        else
        {
                // Update the system with the length of this file.  Subsequent
                // file operations will follow this file.
                assert(File->System);
                File->System->DataLength += File->Length;
                DirTree_SetFileSize(File->DirEntry, File->Length);
        }

        geRam_Free(File);
}

static  geBoolean       GENESISCC ForceFilePos(VFSFile *File)
{
        assert(File);
        assert(File->RWOps);
        assert(!File->Directory);
        
        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        return geVFile_Seek(File->RWOps,
                                          File->RWOpsStartPos + File->CurrentRelPos,
                                          GE_VFILE_SEEKSET);
}

static  int                     ClampOperationSize(const VFSFile *File, int Size)
{
        assert(!File->Directory);
        assert(File->CurrentRelPos >= 0);
        return min(File->Length - File->CurrentRelPos, Size);
}

static  void            GENESISCC UpdateFilePos(VFSFile *File)
{
        long    RWOpsPos;

        assert(!File->Directory);
        assert(File->CurrentRelPos >= 0);

        geVFile_Tell(File->RWOps, &RWOpsPos);

        File->CurrentRelPos = RWOpsPos - File->RWOpsStartPos;
        if      (File->CurrentRelPos > File->Length)
                File->Length = File->CurrentRelPos;

        assert(File->CurrentRelPos >= 0);
}

static  geBoolean       GENESISCC FSVFS_GetS(void *Handle, void *Buff, int MaxLen)
{
        VFSFile *       File;
        geBoolean       Res;

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

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->Directory)
                return GE_FALSE;

        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        if      (!ForceFilePos(File))
                return GE_FALSE;

        MaxLen = ClampOperationSize(File, MaxLen);

        Res = geVFile_GetS(File->RWOps, Buff, MaxLen);

        UpdateFilePos(File);

        return Res;
}

static  geBoolean       GENESISCC FSVFS_Read(void *Handle, void *Buff, int Count)
{
        VFSFile *       File;
        geBoolean       Res;
        int i;
        char Bbyte;
        char *TBuffer;

#ifndef NDEBUG
        int                     CurRelPos;
#endif

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

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->Directory)
                return GE_FALSE;

        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        if      (!ForceFilePos(File))
                return GE_FALSE;

        if      (ClampOperationSize(File, Count) != Count)
                return GE_FALSE;

#ifndef NDEBUG
        CurRelPos = File->CurrentRelPos;
#endif
        Res = geVFile_Read(File->RWOps, Buff, Count);
        TBuffer = Buff;
        for(i=0;i<Count;i++)
        {
                memcpy(&Bbyte, (TBuffer+i),1);
                Bbyte ^=File->Mask;
                memcpy((TBuffer+i),&Bbyte,1);
        }

        UpdateFilePos(File);
        assert(File->CurrentRelPos - CurRelPos == Count);

        return Res;
}

static  geBoolean       GENESISCC FSVFS_Write(void *Handle, const void *Buff, int Count)
{
        VFSFile *       File;
        geBoolean       Res;
        int i;
        char Bbyte;
        char *TBuffer;

#ifndef NDEBUG
        int                     CurRelPos;
#endif

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

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->Directory)
                return GE_FALSE;

        if      (File->OpenModeFlags & GE_VFILE_OPEN_READONLY)
                return GE_FALSE;

        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        if      (!ForceFilePos(File))
                return GE_FALSE;

#ifndef NDEBUG
        CurRelPos = File->CurrentRelPos;
#endif
        TBuffer = (char *)Buff;
        for(i=0;i<Count;i++)
        {
                memcpy(&Bbyte, (TBuffer+i),1);
                Bbyte ^=File->Mask;
                memcpy((TBuffer+i),&Bbyte,1);
        }
        Res = geVFile_Write(File->RWOps, Buff, Count);

        UpdateFilePos(File);
        assert(File->CurrentRelPos - CurRelPos == Count);

        return Res;
}

static  geBoolean       GENESISCC FSVFS_Seek(void *Handle, int Where, geVFile_Whence Whence)
{
        VFSFile *       File;
        geBoolean       Res;
        long            AbsolutePos=0;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->Directory)
                return GE_FALSE;

        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        switch  (Whence)
        {
        case    GE_VFILE_SEEKSET:
                AbsolutePos = File->RWOpsStartPos + Where;
                break;

        case    GE_VFILE_SEEKEND:
                AbsolutePos = File->RWOpsStartPos + File->Length - Where;
                break;

        case    GE_VFILE_SEEKCUR:
                AbsolutePos = File->RWOpsStartPos + File->CurrentRelPos + Where;
                break;

        default:
                assert(!"Illegal seek case");
        }

        if      (AbsolutePos < File->RWOpsStartPos)
                return GE_FALSE;

        Res = geVFile_Seek(File->RWOps, AbsolutePos, GE_VFILE_SEEKSET);

        UpdateFilePos(File);

        return Res;
}

static  geBoolean       GENESISCC FSVFS_EOF(const void *Handle)
{
        const VFSFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->Directory)
                return GE_FALSE;

        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        if      (File->CurrentRelPos == File->Length)
                return GE_TRUE;

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSVFS_Tell(const void *Handle, long *Position)
{
        const VFSFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->Directory)
                return GE_FALSE;

        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        *Position = File->CurrentRelPos;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSVFS_Size(const void *Handle, long *Size)
{
        const VFSFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (File->Directory != NULL)
                return GE_FALSE;

        assert(File->CurrentRelPos >= 0);
        assert(File->CurrentRelPos <= File->Length);

        *Size = File->Length;

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSVFS_GetProperties(const void *Handle, geVFile_Properties *Properties)
{
        const VFSFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->DirEntry);

        DirTree_GetFileTime(File->DirEntry, &Properties->Time);
        DirTree_GetFileAttributes(File->DirEntry, &Properties->AttributeFlags);
        DirTree_GetFileSize(File->DirEntry, &Properties->Size);
        DirTree_GetFileHints(File->DirEntry, &Properties->Hints);
        return DirTree_GetName(File->DirEntry, &Properties->Name[0], sizeof(Properties->Name));
}

static  geBoolean       GENESISCC FSVFS_SetSize(void *Handle, long Size)
{
        assert(!"Not implemented");
        return GE_FALSE;
}

static  geBoolean       GENESISCC FSVFS_SetAttributes(void *Handle, geVFile_Attributes Attributes)
{
        const VFSFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->DirEntry);

        if      (Attributes & ~GE_VFILE_ATTRIB_READONLY)
                return GE_FALSE;

        DirTree_SetFileAttributes(File->DirEntry, Attributes);

        return GE_TRUE;
}

static  geBoolean       GENESISCC FSVFS_SetTime(void *Handle, const geVFile_Time *Time)
{
        const VFSFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->DirEntry);

        DirTree_SetFileTime(File->DirEntry, Time);

        return GE_FALSE;
}

static  geBoolean       GENESISCC FSVFS_SetHints(void *Handle, const geVFile_Hints *Hints)
{
        const VFSFile * File;

        File = Handle;

        CHECK_HANDLE(File);

        assert(File->DirEntry);

        return DirTree_SetFileHints(File->DirEntry, Hints);
}

static  geBoolean       GENESISCC FSVFS_FileExists(geVFile *FS, void *Handle, const char *Name)
{
        VFSFile *       File;

        File = Handle;

        CHECK_HANDLE(File);

        if      (!File->Directory)
                return GE_FALSE;

        return DirTree_FileExists(File->Directory, Name);
}

static  geBoolean       GENESISCC FSVFS_Disperse(
        geVFile *       FS,
        void *          Handle,
        const char *Directory,
        geBoolean       Recursive)
{
assert(!"Not implemented");
        return GE_FALSE;
}

static  geBoolean       GENESISCC FSVFS_DeleteFile(geVFile *FS, void *Handle, const char *Name)
{
assert(!"Not implemented");
        return GE_FALSE;
}

static  geBoolean       GENESISCC FSVFS_RenameFile(geVFile *FS, void *Handle, const char *Name, const char *NewName)
{
assert(!"Not implemented");
        return GE_FALSE;
}

static  geVFile_SystemAPIs      FSVFS_APIs =
{
        FSVFS_FinderCreate,
        FSVFS_FinderGetNextFile,
        FSVFS_FinderGetProperties,
        FSVFS_FinderDestroy,

        FSVFS_OpenNewSystem,
        FSVFS_UpdateContext,
        FSVFS_Open,
        FSVFS_DeleteFile,
        FSVFS_RenameFile,
        FSVFS_FileExists,
        FSVFS_Disperse,
        FSVFS_Close,

        FSVFS_GetS,
        FSVFS_Read,
        FSVFS_Write,
        FSVFS_Seek,
        FSVFS_EOF,
        FSVFS_Tell,
        FSVFS_Size,

        FSVFS_GetProperties,

        FSVFS_SetSize,
        FSVFS_SetAttributes,
        FSVFS_SetTime,
        FSVFS_SetHints,
};

const geVFile_SystemAPIs * GENESISCC FSVFS_GetAPIs(void)
{
        return &FSVFS_APIs;
}

---