VirtFs::FsDir Namespace Reference

Functions
File *	openInternal (FsEntry *const entry, const std::string &filename, const char *mode)
File *	openRead (FsEntry *const entry, std::string filename)
File *	openWrite (FsEntry *const entry, const std::string &filename)
File *	openAppend (FsEntry *const entry, const std::string &filename)
void	deinit ()
void	init (const std::string &name)
void	initFuncs (FsFuncs *const ptr)
FsFuncs *	getFuncs ()
const char *	getBaseDir ()
const char *	getUserDir ()
bool	getRealDir (FsEntry *const entry, std::string filename, std::string dirName, std::string &realDir)
bool	exists (FsEntry *const entry, std::string fileName, std::string dirName)
void	enumerate (FsEntry *const entry, std::string dirName, StringVect &names)
bool	isDirectory (FsEntry *const entry, std::string dirName, bool &isDirFlag)
bool	isSymbolicLink (std::string name)
void	freeList (List *const handle)
bool	setWriteDir (std::string newDir)
bool	mkdir (std::string dirname)
bool	remove (std::string filename)
void	permitLinks (const bool val)
int	close (File *const file)
int64_t	read (File *const file, void *const buffer, const uint32_t objSize, const uint32_t objCount)
int64_t	write (File *const file, const void *const buffer, const uint32_t objSize, const uint32_t objCount)
int64_t	fileLength (File *const file)
int64_t	tell (File *const file)
int	seek (File *const file, const uint64_t pos)
int	eof (File *const file)
const char *	loadFile (FsEntry *const entry, std::string filename, int &fileSize)
void	getFiles (FsEntry *const entry, std::string dirName, StringVect &names)
void	getFilesWithDir (FsEntry *const entry, const std::string &dirName, StringVect &names)
void	getDirs (FsEntry *const entry, std::string dirName, StringVect &names)
int32_t	rwops_seek (SDL_RWops *const rw, const int32_t offset, const int whence)
int	rwops_read (SDL_RWops *const rw, void *const ptr, const int size, const int maxnum)
int	rwops_write (SDL_RWops *const rw, const void *const ptr, const int size, const int maxnum)
int	rwops_close (SDL_RWops *const rw)

Function Documentation

close()

int VirtFs::FsDir::close

(

File *const

file

)

Definition at line 312 of file fsdir.cpp.

    {
        if (file == nullptr)
            return 0;
        delete file;
        return 1;
    }

Referenced by initFuncs().

deinit()

void VirtFs::FsDir::deinit

(

)

Definition at line 101 of file fsdir.cpp.

    {
    }

Referenced by VirtFs::deinit().

enumerate()

void VirtFs::FsDir::enumerate	(	FsEntry *const	entry,
		std::string	dirName,
		StringVect &	names
	)

Definition at line 192 of file fsdir.cpp.

    {
        const std::string path = static_cast<DirEntry*>(entry)->rootSubDir +
            dirName;
        const dirent *next_file = nullptr;
        DIR *const dir = opendir(path.c_str());
        if (dir != nullptr)
        {
            while ((next_file = readdir(dir)) != nullptr)
            {
                const std::string file = next_file->d_name;
                if (file == "." || file == "..")
                    continue;
#ifndef WIN32
                if (mPermitLinks == false)
                {
                    struct stat statbuf;
                    if (lstat(path.c_str(), &statbuf) == 0 &&
                        S_ISLNK(statbuf.st_mode) != 0)
                    {
                        continue;
                    }
                }
#endif  // WIN32
 
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == file)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                    names.push_back(file);
            }
            closedir(dir);
        }
    }

References FOR_EACH, and VirtFs::anonymous_namespace{fsdir.cpp}::mPermitLinks.

Referenced by initFuncs().

eof()

int VirtFs::FsDir::eof

(

File *const

file

)

Definition at line 436 of file fsdir.cpp.

    {
        if (file == nullptr)
            return -1;
 
        FILEHTYPE fd = file->mFd;
        if (fd == FILEHDEFAULT)
        {
            reportAlways("FsDir::eof file not opened.")
            return 0;
        }
#ifdef USE_FILE_FOPEN
        const int flag = feof(fd);
        if (flag != 0)
            return 1;
        const int64_t pos = ftell(fd);
        const int64_t len = fileLength(file);
#else  // USE_FILE_FOPEN
        const int64_t pos = lseek(fd, 0, SEEK_CUR);
        struct stat statbuf;
        if (fstat(fd, &statbuf) == -1)
        {
            reportAlways("FsDir::fileLength error.")
            return -1;
        }
        const int64_t len = static_cast<int64_t>(statbuf.st_size);
#endif  // USE_FILE_FOPEN
        return static_cast<int>(pos < 0 || len < 0 || pos >= len);
    }

References FILEHDEFAULT, FILEHTYPE, fileLength(), and reportAlways.

Referenced by initFuncs().

exists()

bool VirtFs::FsDir::exists	(	FsEntry *const	entry,
		std::string	fileName,
		std::string	dirName
	)

Definition at line 184 of file fsdir.cpp.

    {
        return Files::existsLocal(static_cast<DirEntry*>(entry)->rootSubDir +
            fileName);
    }

References Files::existsLocal(), and fileName.

Referenced by initFuncs().

fileLength()

int64_t VirtFs::FsDir::fileLength

(

File *const

file

)

Definition at line 368 of file fsdir.cpp.

    {
        if (file == nullptr)
            return -1;
        FILEHTYPE fd = file->mFd;
        if (fd == FILEHDEFAULT)
        {
            reportAlways("FsDir::fileLength file not opened.")
            return 0;
        }
#ifdef USE_FILE_FOPEN
        const long pos = ftell(fd);
        if (pos < 0)
        {
            reportAlways("FsDir::fileLength ftell error.")
            return -1;
        }
        fseek(fd, 0, SEEK_END);
        const long sz = ftell(fd);
        fseek(fd, pos, SEEK_SET);
        return sz;
#else  // USE_FILE_FOPEN
        struct stat statbuf;
        if (fstat(fd, &statbuf) == -1)
        {
            reportAlways("FsDir::fileLength error.")
            return -1;
        }
        return static_cast<int64_t>(statbuf.st_size);
#endif  // USE_FILE_FOPEN
    }

References FILEHDEFAULT, FILEHTYPE, and reportAlways.

Referenced by eof(), and initFuncs().

freeList()

void VirtFs::FsDir::freeList

(

List *const

handle

)

Definition at line 271 of file fsdir.cpp.

    {
        delete handle;
    }

getBaseDir()

const char * VirtFs::FsDir::getBaseDir

(

)

Definition at line 160 of file fsdir.cpp.

    {
        return mBaseDir.c_str();
    }

References VirtFs::anonymous_namespace{fsdir.cpp}::mBaseDir.

Referenced by VirtFs::getBaseDir().

getDirs()

void VirtFs::FsDir::getDirs	(	FsEntry *const	entry,
		std::string	dirName,
		StringVect &	names
	)

Definition at line 636 of file fsdir.cpp.

    {
        const std::string path = static_cast<DirEntry*>(entry)->rootSubDir +
            dirName;
        const dirent *next_file = nullptr;
        DIR *const dir = opendir(path.c_str());
        if (dir != nullptr)
        {
            while ((next_file = readdir(dir)) != nullptr)
            {
                struct stat statbuf;
                const std::string file = next_file->d_name;
                if (file == "." || file == "..")
                    continue;
#ifndef WIN32
                if (mPermitLinks == false)
                {
                    if (lstat(path.c_str(), &statbuf) == 0 &&
                        S_ISLNK(statbuf.st_mode) != 0)
                    {
                        continue;
                    }
                }
#endif  // WIN32
 
                const std::string filePath = pathJoin(path, file);
                if (stat(filePath.c_str(), &statbuf) == 0)
                {
                    if (S_ISDIR(statbuf.st_mode) == 0)
                        continue;
                }
 
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == file)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                    names.push_back(file);
            }
            closedir(dir);
        }
    }

References FOR_EACH, VirtFs::anonymous_namespace{fsdir.cpp}::mPermitLinks, and pathJoin().

Referenced by initFuncs().

getFiles()

void VirtFs::FsDir::getFiles	(	FsEntry *const	entry,
		std::string	dirName,
		StringVect &	names
	)

Definition at line 536 of file fsdir.cpp.

    {
        const std::string path = static_cast<DirEntry*>(entry)->rootSubDir +
            dirName;
        const dirent *next_file = nullptr;
        DIR *const dir = opendir(path.c_str());
        if (dir != nullptr)
        {
            while ((next_file = readdir(dir)) != nullptr)
            {
                struct stat statbuf;
                const std::string file = next_file->d_name;
                if (file == "." || file == "..")
                    continue;
#ifndef WIN32
                if (mPermitLinks == false)
                {
                    if (lstat(path.c_str(), &statbuf) == 0 &&
                        S_ISLNK(statbuf.st_mode) != 0)
                    {
                        continue;
                    }
                }
#endif  // WIN32
 
                const std::string filePath = pathJoin(path, file);
                if (stat(filePath.c_str(), &statbuf) == 0)
                {
                    if (S_ISDIR(statbuf.st_mode) != 0)
                        continue;
                }
 
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == file)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                    names.push_back(file);
            }
            closedir(dir);
        }
    }

References FOR_EACH, VirtFs::anonymous_namespace{fsdir.cpp}::mPermitLinks, and pathJoin().

Referenced by initFuncs().

getFilesWithDir()

void VirtFs::FsDir::getFilesWithDir	(	FsEntry *const	entry,
		const std::string &	dirName,
		StringVect &	names
	)

Definition at line 586 of file fsdir.cpp.

    {
        const std::string path = static_cast<DirEntry*>(entry)->rootSubDir +
            dirName;
        const dirent *next_file = nullptr;
        DIR *const dir = opendir(path.c_str());
        if (dir != nullptr)
        {
            while ((next_file = readdir(dir)) != nullptr)
            {
                struct stat statbuf;
                const std::string file = next_file->d_name;
                if (file == "." || file == "..")
                    continue;
#ifndef WIN32
                if (mPermitLinks == false)
                {
                    if (lstat(path.c_str(), &statbuf) == 0 &&
                        S_ISLNK(statbuf.st_mode) != 0)
                    {
                        continue;
                    }
                }
#endif  // WIN32
 
                const std::string filePath = pathJoin(path, file);
                if (stat(filePath.c_str(), &statbuf) == 0)
                {
                    if (S_ISDIR(statbuf.st_mode) != 0)
                        continue;
                }
 
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == file)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                    names.push_back(pathJoin(dirName, file));
            }
            closedir(dir);
        }
    }

References FOR_EACH, VirtFs::anonymous_namespace{fsdir.cpp}::mPermitLinks, and pathJoin().

Referenced by initFuncs().

getFuncs()

FsFuncs * VirtFs::FsDir::getFuncs

(

)

Definition at line 155 of file fsdir.cpp.

    {
        return &funcs;
    }

References VirtFs::anonymous_namespace{fsdir.cpp}::funcs.

Referenced by VirtFs::mountDirInternal().

getRealDir()

bool VirtFs::FsDir::getRealDir	(	FsEntry *const	entry,
		std::string	filename,
		std::string	dirName,
		std::string &	realDir
	)

Definition at line 170 of file fsdir.cpp.

    {
        const DirEntry *const dirEntry = static_cast<const DirEntry*>(entry);
        if (Files::existsLocal(dirEntry->rootSubDir + filename))
        {
            realDir = dirEntry->userDir;
            return true;
        }
        return false;
    }

References Files::existsLocal(), VirtFs::DirEntry::rootSubDir, and VirtFs::DirEntry::userDir.

Referenced by initFuncs().

getUserDir()

const char * VirtFs::FsDir::getUserDir

(

)

Definition at line 165 of file fsdir.cpp.

    {
        return mUserDir.c_str();
    }

References VirtFs::anonymous_namespace{fsdir.cpp}::mUserDir.

Referenced by VirtFs::getUserDir().

init()

void VirtFs::FsDir::init

(

const std::string &

name

)

Definition at line 115 of file fsdir.cpp.

    {
        mBaseDir = getRealPath(getFileDir(name));
#endif  // defined(__native_client__)
 
        prepareFsPath(mBaseDir);
        mUserDir = getHomePath();
        prepareFsPath(mUserDir);
        initFuncs(&funcs);
    }

References VirtFs::anonymous_namespace{fsdir.cpp}::funcs, getFileDir(), getHomePath(), getRealPath(), initFuncs(), VirtFs::anonymous_namespace{fsdir.cpp}::mBaseDir, VirtFs::anonymous_namespace{fsdir.cpp}::mUserDir, and prepareFsPath().

Referenced by VirtFs::init().

initFuncs()

void VirtFs::FsDir::initFuncs

(

FsFuncs *const

ptr

)

Definition at line 126 of file fsdir.cpp.

    {
        ptr->close = &FsDir::close;
        ptr->read = &FsDir::read;
        ptr->write = &FsDir::write;
        ptr->fileLength = &FsDir::fileLength;
        ptr->tell = &FsDir::tell;
        ptr->seek = &FsDir::seek;
        ptr->eof = &FsDir::eof;
        ptr->exists = &FsDir::exists;
        ptr->getRealDir = &FsDir::getRealDir;
        ptr->enumerate = &FsDir::enumerate;
        ptr->isDirectory = &FsDir::isDirectory;
        ptr->openRead = &FsDir::openRead;
        ptr->openWrite = &FsDir::openWrite;
        ptr->openAppend = &FsDir::openAppend;
        ptr->loadFile = &FsDir::loadFile;
        ptr->getFiles = &FsDir::getFiles;
        ptr->getFilesWithDir = &FsDir::getFilesWithDir;
        ptr->getDirs = &FsDir::getDirs;
        ptr->rwops_seek = &FsDir::rwops_seek;
        ptr->rwops_read = &FsDir::rwops_read;
        ptr->rwops_write = &FsDir::rwops_write;
        ptr->rwops_close = &FsDir::rwops_close;
#ifdef USE_SDL2
        ptr->rwops_size = &FsDir::rwops_size;
#endif  // USE_SDL2
    }

References close(), enumerate(), eof(), exists(), fileLength(), getDirs(), getFiles(), getFilesWithDir(), getRealDir(), isDirectory(), loadFile(), openAppend(), openRead(), openWrite(), read(), rwops_close(), rwops_read(), rwops_seek(), rwops_write(), seek(), tell(), and write().

Referenced by init().

isDirectory()

bool VirtFs::FsDir::isDirectory	(	FsEntry *const	entry,
		std::string	dirName,
		bool &	isDirFlag
	)

Definition at line 235 of file fsdir.cpp.

    {
        std::string path = static_cast<DirEntry*>(entry)->rootSubDir + dirName;
 
        struct stat statbuf;
        if (stat(path.c_str(), &statbuf) == 0)
        {
            isDirFlag = (S_ISDIR(statbuf.st_mode) != 0);
            return true;
        }
        return false;
    }

Referenced by initFuncs().

isSymbolicLink()

bool VirtFs::FsDir::isSymbolicLink

(

std::string

name

)

Definition at line 250 of file fsdir.cpp.

    {
        prepareFsPath(name);
        if (checkPath(name) == false)
        {
            reportAlways("FsDir::isSymbolicLink invalid path: %s",
                name.c_str())
            return false;
        }
#ifndef WIN32
        if (mPermitLinks == false)
            return false;
 
        struct stat statbuf;
        return lstat(name.c_str(), &statbuf) == 0 &&
            S_ISLNK(statbuf.st_mode) != 0;
#else
        return false;
#endif  // WIN32
    }

References checkPath(), VirtFs::anonymous_namespace{fsdir.cpp}::mPermitLinks, prepareFsPath(), and reportAlways.

Referenced by VirtFs::isSymbolicLink().

loadFile()

const char * VirtFs::FsDir::loadFile	(	FsEntry *const	entry,
		std::string	filename,
		int &	fileSize
	)

Definition at line 466 of file fsdir.cpp.

    {
        const DirEntry *const dirEntry = static_cast<DirEntry*>(entry);
        const std::string path = dirEntry->rootSubDir + filename;
        if (Files::existsLocal(path) == false)
            return nullptr;
        FILEHTYPE fd = FILEOPEN(path.c_str(),
            FILEOPEN_FLAG_READ);
        if (fd == FILEHDEFAULT)
        {
            reportAlways("VirtFs::loadFile file open error: %s",
                filename.c_str())
            return nullptr;
        }
 
        logger->log("Loaded %s/%s",
            dirEntry->userDir.c_str(),
            filename.c_str());
 
#ifdef USE_FILE_FOPEN
        fseek(fd, 0, SEEK_END);
        const long sz = ftell(fd);
        if (sz < 0)
        {
            reportAlways("FsDir::fileLength ftell error.")
            if (fd != FILEHDEFAULT)
                FILECLOSE(fd);
            return nullptr;
        }
        fseek(fd, 0, SEEK_SET);
        fileSize = static_cast<int>(sz);
#else  // USE_FILE_FOPEN
        struct stat statbuf;
        if (fstat(fd, &statbuf) == -1)
        {
            reportAlways("FsDir::fileLength error.")
            if (fd != FILEHDEFAULT)
                FILECLOSE(fd);
            return nullptr;
        }
        fileSize = static_cast<int>(statbuf.st_size);
#endif  // USE_FILE_FOPEN
 
        // Allocate memory and load the file
        char *restrict const buffer = new char[CAST_SIZE(fileSize)];
        if (fileSize > 0)
            buffer[fileSize - 1] = 0;
 
#ifdef USE_FILE_FOPEN
        const int cnt = CAST_S32(fread(buffer, 1, fileSize, fd));
#else  // USE_FILE_FOPEN
        const int cnt = ::read(fd, buffer, fileSize);
#endif  // USE_FILE_FOPEN
 
        if (cnt <= 0)
        {
            delete [] buffer;
            if (fd != FILEHDEFAULT)
                FILECLOSE(fd);
            return nullptr;
        }
 
        if (fd != FILEHDEFAULT)
            FILECLOSE(fd);
 
        return buffer;
    }

References CAST_S32, CAST_SIZE, Files::existsLocal(), FILECLOSE, FILEHDEFAULT, FILEHTYPE, FILEOPEN, FILEOPEN_FLAG_READ, Logger::log(), logger, read(), reportAlways, restrict, VirtFs::DirEntry::rootSubDir, and VirtFs::DirEntry::userDir.

Referenced by initFuncs().

mkdir()

bool VirtFs::FsDir::mkdir

(

std::string

dirname

)

Definition at line 285 of file fsdir.cpp.

    {
        prepareFsPath(dirname);
        if (mWriteDir.empty())
        {
            reportAlways("FsDir::mkdir write dir is empty")
            return false;
        }
        return mkdir_r((mWriteDir + dirname).c_str()) != -1;
    }

References mkdir_r(), VirtFs::anonymous_namespace{fsdir.cpp}::mWriteDir, prepareFsPath(), and reportAlways.

Referenced by VirtFs::mkdir().

openAppend()

File * VirtFs::FsDir::openAppend	(	FsEntry *const	entry,
		const std::string &	filename
	)

Definition at line 95 of file fsdir.cpp.

    {
        return openInternal(entry, filename, FILEOPEN_FLAG_APPEND);
    }

References FILEOPEN_FLAG_APPEND, and openInternal().

Referenced by initFuncs().

openInternal()

File * VirtFs::FsDir::openInternal	(	FsEntry *const	entry,
		const std::string &	filename,
		const char *	mode
	)

Definition at line 64 of file fsdir.cpp.

    {
        const std::string path = static_cast<DirEntry*>(entry)->rootSubDir +
            filename;
        if (Files::existsLocal(path) == false)
            return nullptr;
        FILEHTYPE fd = FILEOPEN(path.c_str(),
            mode);
        if (fd == FILEHDEFAULT)
        {
            reportAlways("VirtFs::open file open error: %s",
                filename.c_str())
            return nullptr;
        }
        return new File(&funcs, fd);
    }

References Files::existsLocal(), FILEHDEFAULT, FILEHTYPE, FILEOPEN, VirtFs::anonymous_namespace{fsdir.cpp}::funcs, and reportAlways.

Referenced by openAppend(), openRead(), and openWrite().

openRead()

File * VirtFs::FsDir::openRead	(	FsEntry *const	entry,
		std::string	filename
	)

Definition at line 83 of file fsdir.cpp.

    {
        return openInternal(entry, filename, FILEOPEN_FLAG_READ);
    }

References FILEOPEN_FLAG_READ, and openInternal().

Referenced by initFuncs().

openWrite()

File * VirtFs::FsDir::openWrite	(	FsEntry *const	entry,
		const std::string &	filename
	)

Definition at line 89 of file fsdir.cpp.

    {
        return openInternal(entry, filename, FILEOPEN_FLAG_WRITE);
    }

References FILEOPEN_FLAG_WRITE, and openInternal().

Referenced by initFuncs().

permitLinks()

void VirtFs::FsDir::permitLinks

(

const bool

val

)

Definition at line 307 of file fsdir.cpp.

    {
        mPermitLinks = val;
    }

References VirtFs::anonymous_namespace{fsdir.cpp}::mPermitLinks.

Referenced by VirtFs::permitLinks().

read()

int64_t VirtFs::FsDir::read	(	File *const	file,
		void *const	buffer,
		const uint32_t	objSize,
		const uint32_t	objCount
	)

Definition at line 320 of file fsdir.cpp.

    {
        if (file == nullptr)
            return 0;
        FILEHTYPE fd = file->mFd;
        if (fd == FILEHDEFAULT)
        {
            reportAlways("FsDir::read file not opened.")
            return 0;
        }
#ifdef USE_FILE_FOPEN
        return fread(buffer, objSize, objCount, fd);
#else  // USE_FILE_FOPEN
        int max = objSize * objCount;
        int cnt = ::read(fd, buffer, max);
        if (cnt <= 0)
            return cnt;
        return cnt / objSize;
#endif  // USE_FILE_FOPEN
    }

References FILEHDEFAULT, FILEHTYPE, and reportAlways.

Referenced by initFuncs(), loadFile(), and rwops_read().

remove()

bool VirtFs::FsDir::remove

(

std::string

filename

)

Definition at line 296 of file fsdir.cpp.

    {
        prepareFsPath(filename);
        if (mWriteDir.empty())
        {
            reportAlways("FsDir::remove write dir is empty")
            return false;
        }
        return ::remove((mWriteDir + filename).c_str()) != 0;
    }

References VirtFs::anonymous_namespace{fsdir.cpp}::mWriteDir, prepareFsPath(), and reportAlways.

Referenced by VirtFs::remove().

rwops_close()

int VirtFs::FsDir::rwops_close

(

SDL_RWops *const

rw

)

Definition at line 233 of file fsdirrwops.cpp.

    {
        if (rw == nullptr)
            return 0;
        File *const handle = static_cast<File*>(
            rw->hidden.unknown.data1);
        delete handle;
        SDL_FreeRW(rw);
        return 0;
    }

Referenced by initFuncs().

rwops_read()

int VirtFs::FsDir::rwops_read	(	SDL_RWops *const	rw,
		void *const	ptr,
		const int	size,
		const int	maxnum
	)

Definition at line 160 of file fsdirrwops.cpp.

    {
        if (rw == nullptr)
            return 0;
        File *const handle = static_cast<File *>(
            rw->hidden.unknown.data1);
        FILEHTYPE fd = handle->mFd;
 
#ifdef USE_FILE_FOPEN
        const int64_t rc = fread(ptr, size, maxnum, fd);
#else  // USE_FILE_FOPEN
        int max = size * maxnum;
        int cnt = ::read(fd, ptr, max);
        if (cnt <= 0)
            return cnt;
        const int64_t rc = cnt / size;
#endif  // USE_FILE_FOPEN
 
#ifndef USE_FILE_FOPEN
        if (rc != static_cast<int64_t>(maxnum))
        {
            const int64_t pos = lseek(fd, 0, SEEK_CUR);
            struct stat statbuf;
            if (fstat(fd, &statbuf) == -1)
            {
                reportAlways("FsDir::fileLength error.")
                return CAST_S32(rc);
            }
        }
#endif  // USE_FILE_FOPEN
        return CAST_S32(rc);
    }

References CAST_S32, FILEHTYPE, VirtFs::File::mFd, read(), reportAlways, and EmoteDB::size().

Referenced by initFuncs().

rwops_seek()

int32_t VirtFs::FsDir::rwops_seek	(	SDL_RWops *const	rw,
		const int32_t	offset,
		const int	whence
	)

Definition at line 41 of file fsdirrwops.cpp.

    {
        if (rw == nullptr)
            return -1;
        File *const handle = static_cast<File *>(
            rw->hidden.unknown.data1);
        FILEHTYPE fd = handle->mFd;
        RWOPSINT pos = 0;
 
        if (whence == SEEK_SET)
        {
            pos = offset;
        }
        else if (whence == SEEK_CUR)
        {
#ifdef USE_FILE_FOPEN
            const int64_t current = ftell(fd);
#else  // USE_FILE_FOPEN
            const int64_t current = lseek(fd, 0, SEEK_CUR);
#endif  // USE_FILE_FOPEN
 
            if (current == -1)
            {
                logger->assertLog(
                    "VirtFs::rwops_seek: Can't find position in file.");
                return -1;
            }
 
            pos = CAST_S32(current);
            if (static_cast<int64_t>(pos) != current)
            {
                logger->assertLog("VirtFs::rwops_seek: "
                    "Can't fit current file position in an int!");
                return -1;
            }
 
            if (offset == 0)  /* this is a "tell" call. We're done. */
                return pos;
 
            pos += offset;
        }
        else if (whence == SEEK_END)
        {
            int64_t len = 0;
#ifdef USE_FILE_FOPEN
            const long curpos = ftell(fd);
            if (curpos < 0)
            {
                reportAlways("FsDir::fileLength ftell error.")
                return -1;
            }
            fseek(fd, 0, SEEK_END);
            len = ftell(fd);
//            fseek(fd, curpos, SEEK_SET);
#else  // USE_FILE_FOPEN
            struct stat statbuf;
            if (fstat(fd, &statbuf) == -1)
            {
                reportAlways("FsDir::fileLength error.")
                len = -1;
            }
            else
            {
                len = static_cast<int64_t>(statbuf.st_size);
            }
#endif  // USE_FILE_FOPEN
 
            if (len == -1)
            {
#ifdef USE_FILE_FOPEN
                if (fseek(fd, curpos, SEEK_SET) < 0)
                {
                    reportAlways("FsDir::fileLength fseek error.")
                }
#endif  // USE_FILE_FOPEN
                logger->assertLog(
                    "VirtFs::rwops_seek:Can't find end of file.");
                return -1;
            }
 
            pos = static_cast<RWOPSINT>(len);
            if (static_cast<int64_t>(pos) != len)
            {
#ifdef USE_FILE_FOPEN
                fseek(fd, curpos, SEEK_SET);
#endif  // USE_FILE_FOPEN
                logger->assertLog("VirtFs::rwops_seek: "
                    "Can't fit end-of-file position in an int!");
                return -1;
            }
 
            pos += offset;
        }
        else
        {
            logger->assertLog(
                "VirtFs::rwops_seek: Invalid 'whence' parameter.");
            return -1;
        }
 
        if (pos < 0)
        {
            logger->assertLog("VirtFs::rwops_seek: "
                "Attempt to seek past start of file.");
            return -1;
        }
 
        const int64_t res = FILESEEK(fd, pos, SEEK_SET);
        if (res == -1)
        {
            logger->assertLog("VirtFs::rwops_seek: seek error.");
            return -1;
        }
 
        return pos;
    }

References Logger::assertLog(), CAST_S32, FILEHTYPE, FILESEEK, logger, VirtFs::File::mFd, reportAlways, and RWOPSINT.

Referenced by initFuncs().

rwops_write()

int VirtFs::FsDir::rwops_write	(	SDL_RWops *const	rw,
		const void *const	ptr,
		const int	size,
		const int	maxnum
	)

Definition at line 196 of file fsdirrwops.cpp.

    {
        if (rw == nullptr)
            return 0;
        File *const handle = static_cast<File *>(
            rw->hidden.unknown.data1);
        FILEHTYPE fd = handle->mFd;
 
#ifdef USE_FILE_FOPEN
        const int64_t rc = fwrite(ptr, size, maxnum, fd);
#else  // USE_FILE_FOPEN
        int max = size * maxnum;
        int cnt = ::write(fd, ptr, max);
        if (cnt <= 0)
            return cnt;
        const int64_t rc = cnt / size;
#endif  // USE_FILE_FOPEN
 
#ifndef USE_FILE_FOPEN
        if (rc != static_cast<int64_t>(maxnum))
        {
            const int64_t pos = lseek(fd, 0, SEEK_CUR);
            struct stat statbuf;
            if (fstat(fd, &statbuf) == -1)
            {
                reportAlways("FsDir::fileLength error.")
                return CAST_S32(rc);
            }
        }
#endif  // USE_FILE_FOPEN
 
        return CAST_S32(rc);
    }

References CAST_S32, FILEHTYPE, VirtFs::File::mFd, reportAlways, EmoteDB::size(), and write().

Referenced by initFuncs().

seek()

int VirtFs::FsDir::seek	(	File *const	file,
		const uint64_t	pos
	)

Definition at line 418 of file fsdir.cpp.

    {
        if (file == nullptr)
            return 0;
 
        FILEHTYPE fd = file->mFd;
        if (fd == FILEHDEFAULT)
        {
            reportAlways("FsDir::seek file not opened.")
            return 0;
        }
        const int64_t res = FILESEEK(fd, pos, SEEK_SET);
        if (res == -1)
            return 0;
        return 1;
    }

References FILEHDEFAULT, FILEHTYPE, FILESEEK, and reportAlways.

Referenced by initFuncs().

setWriteDir()

bool VirtFs::FsDir::setWriteDir

(

std::string

newDir

)

Definition at line 276 of file fsdir.cpp.

    {
        prepareFsPath(newDir);
        mWriteDir = STD_MOVE(newDir);
        if (findLast(mWriteDir, std::string(dirSeparator)) == false)
            mWriteDir += dirSeparator;
        return true;
    }

References dirSeparator, findLast(), VirtFs::anonymous_namespace{fsdir.cpp}::mWriteDir, prepareFsPath(), and STD_MOVE.

Referenced by VirtFs::setWriteDir().

tell()

int64_t VirtFs::FsDir::tell

(

File *const

file

)

Definition at line 400 of file fsdir.cpp.

    {
        if (file == nullptr)
            return -1;
 
        FILEHTYPE fd = file->mFd;
        if (fd == FILEHDEFAULT)
        {
            reportAlways("FsDir::tell file not opened.")
            return 0;
        }
#ifdef USE_FILE_FOPEN
        return ftell(fd);
#else  // USE_FILE_FOPEN
        return lseek(fd, 0, SEEK_CUR);
#endif  // USE_FILE_FOPEN
    }

References FILEHDEFAULT, FILEHTYPE, and reportAlways.

Referenced by initFuncs().

write()

int64_t VirtFs::FsDir::write	(	File *const	file,
		const void *const	buffer,
		const uint32_t	objSize,
		const uint32_t	objCount
	)

Definition at line 344 of file fsdir.cpp.

    {
        if (file == nullptr)
            return 0;
        FILEHTYPE fd = file->mFd;
        if (fd == FILEHDEFAULT)
        {
            reportAlways("FsDir::write file not opened.")
            return 0;
        }
#ifdef USE_FILE_FOPEN
        return fwrite(buffer, objSize, objCount, fd);
#else  // USE_FILE_FOPEN
        int max = objSize * objCount;
        int cnt = ::write(fd, buffer, max);
        if (cnt <= 0)
            return cnt;
        return cnt / objSize;
#endif  // USE_FILE_FOPEN
    }

References FILEHDEFAULT, FILEHTYPE, and reportAlways.

Referenced by initFuncs(), and rwops_write().