Head

GCC Code Coverage Report

Directory:	src/		Exec	Total	Coverage
File:	src/fs/virtfs/fszip.cpp	Lines:	245	289	84.8 %
Date:	2021-03-17	Branches:	201	338	59.5 %


/*
 *  The ManaPlus Client
 *  Copyright (C) 2013-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "fs/virtfs/fszip.h"

#include "fs/virtfs/file.h"
#include "fs/virtfs/fsfuncs.h"
#include "fs/virtfs/fsziprwops.h"
#include "fs/virtfs/list.h"
#include "fs/virtfs/zipentry.h"
#include "fs/virtfs/zipreader.h"
#include "fs/virtfs/ziplocalheader.h"

#include "utils/cast.h"
#include "utils/checkutils.h"
#include "utils/foreach.h"
#include "utils/stringutils.h"

#include "debug.h"

extern const char *dirSeparator;

namespace
{
    VirtFs::FsFuncs funcs;
}  // namespace

namespace VirtFs
{

namespace FsZip
{
    FsFuncs *getFuncs()
    {
        return &funcs;
    }

    void deinit()
    {
    }

    void init()
    {
        initFuncs(&funcs);
    }

    void initFuncs(FsFuncs *restrict const ptr)
    {
        ptr->close = &FsZip::close;
        ptr->read = &FsZip::read;
        ptr->write = &FsZip::write;
        ptr->fileLength = &FsZip::fileLength;
        ptr->tell = &FsZip::tell;
        ptr->seek = &FsZip::seek;
        ptr->eof = &FsZip::eof;
        ptr->exists = &FsZip::exists;
        ptr->getRealDir = &FsZip::getRealDir;
        ptr->enumerate = &FsZip::enumerate;
        ptr->isDirectory = &FsZip::isDirectory;
        ptr->openRead = &FsZip::openRead;
        ptr->openWrite = &FsZip::openWrite;
        ptr->openAppend = &FsZip::openAppend;
        ptr->loadFile = &FsZip::loadFile;
        ptr->getFiles = &FsZip::getFiles;
        ptr->getFilesWithDir = &FsZip::getFilesWithDir;
        ptr->getDirs = &FsZip::getDirs;
        ptr->rwops_seek = &FsZip::rwops_seek;
        ptr->rwops_read = &FsZip::rwops_read;
        ptr->rwops_write = &FsZip::rwops_write;
        ptr->rwops_close = &FsZip::rwops_close;
#ifdef USE_SDL2
        ptr->rwops_size = &FsZip::rwops_size;
#endif  // USE_SDL2
    }

    bool getRealDir(FsEntry *restrict const entry,
                    std::string filename,
                    std::string dirName,
                    std::string &realDir)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
        {
            filename = pathJoin(subDir, filename);
            dirName = pathJoin(subDir, dirName);
        }
        FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                  it2,
                  zipEntry->mHeaders)
        {
            if ((*it2)->fileName == filename)
            {
                realDir = entry->root;
                return true;
            }
        }
        FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                  it2,
                  zipEntry->mDirs)
        {
            if (*it2 == dirName)
            {
                realDir = entry->root;
                return true;
            }
        }
        return false;
    }

    bool exists(FsEntry *restrict const entry,
                std::string filename,
                std::string dirName)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
        {
            filename = pathJoin(subDir, filename);
            dirName = pathJoin(subDir, dirName);
        }
        FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                  it2,
                  zipEntry->mHeaders)
        {
            if ((*it2)->fileName == filename)
                return true;
        }
        FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                  it2,
                  zipEntry->mDirs)
        {
            if (*it2 == dirName)
                return true;
        }
        return false;
    }

    void enumerate(FsEntry *restrict const entry,
                   std::string dirName,
                   StringVect &names)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        const std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
            dirName = pathJoin(subDir, dirName);
        if (dirName == dirSeparator)
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                // skip subdirs from enumeration
                const size_t idx = fileName.find(dirSeparator);
                if (idx != std::string::npos)
                    fileName.erase(idx);
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == fileName)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                    names.push_back(fileName);
            }
        }
        else
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                if (findCutFirst(fileName, dirName) == true)
                {
                    // skip subdirs from enumeration
                    const size_t idx = fileName.find(dirSeparator);
                    if (idx != std::string::npos)
                        fileName.erase(idx);
                    bool found(false);
                    FOR_EACH (StringVectCIter, itn, names)
                    {
                        if (*itn == fileName)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == false)
                        names.push_back(fileName);
                }
            }
        }
    }

    void getFiles(FsEntry *restrict const entry,
                  std::string dirName,
                  StringVect &names)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        const std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
            dirName = pathJoin(subDir, dirName);
        if (dirName == dirSeparator)
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                // skip subdirs from enumeration
                const size_t idx = fileName.find(dirSeparator);
                if (idx != std::string::npos)
                    fileName.erase(idx);
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == fileName)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                {
                    std::string dirName2 = pathJoin(dirName, fileName);
                    if (findLast(dirName2, std::string(dirSeparator)) == false)
                        dirName2 += dirSeparator;
                    FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                              it,
                              zipEntry->mDirs)
                    {
                        if (*it == dirName2)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == false)
                        names.push_back(fileName);
                }
            }
        }
        else
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                if (findCutFirst(fileName, dirName) == true)
                {
                    // skip subdirs from enumeration
                    const size_t idx = fileName.find(dirSeparator);
                    if (idx != std::string::npos)
                        fileName.erase(idx);
                    bool found(false);
                    FOR_EACH (StringVectCIter, itn, names)
                    {
                        if (*itn == fileName)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == false)
                    {
                        std::string dirName2 = pathJoin(dirName, fileName);
                        if (findLast(dirName2, std::string(dirSeparator)) ==
                            false)
                        {
                            dirName2 += dirSeparator;
                        }
                        FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                                  it,
                                  zipEntry->mDirs)
                        {
                            if (*it == dirName2)
                            {
                                found = true;
                                break;
                            }
                        }
                        if (found == false)
                            names.push_back(fileName);
                    }
                }
            }
        }
    }

    void getFilesWithDir(FsEntry *restrict const entry,
                         const std::string &dirName,
                         StringVect &names)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        const std::string subDir = zipEntry->subDir;
        std::string dirNameFull;
        if (!subDir.empty())
            dirNameFull = pathJoin(subDir, dirName);
        else
            dirNameFull = dirName;
        if (dirNameFull == dirSeparator)
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                // skip subdirs from enumeration
                const size_t idx = fileName.find(dirSeparator);
                if (idx != std::string::npos)
                    fileName.erase(idx);
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == fileName)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                {
                    std::string dirName2 = pathJoin(dirNameFull, fileName);
                    if (findLast(dirName2, std::string(dirSeparator)) == false)
                        dirName2 += dirSeparator;
                    FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                              it,
                              zipEntry->mDirs)
                    {
                        if (*it == dirName2)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == false)
                        names.push_back(pathJoin(dirName, fileName));
                }
            }
        }
        else
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                if (findCutFirst(fileName, dirNameFull) == true)
                {
                    // skip subdirs from enumeration
                    const size_t idx = fileName.find(dirSeparator);
                    if (idx != std::string::npos)
                        fileName.erase(idx);
                    bool found(false);
                    FOR_EACH (StringVectCIter, itn, names)
                    {
                        if (*itn == fileName)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == false)
                    {
                        std::string dirName2 = pathJoin(dirNameFull, fileName);
                        if (findLast(dirName2, std::string(dirSeparator)) ==
                            false)
                        {
                            dirName2 += dirSeparator;
                        }
                        FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                                  it,
                                  zipEntry->mDirs)
                        {
                            if (*it == dirName2)
                            {
                                found = true;
                                break;
                            }
                        }
                        if (found == false)
                            names.push_back(pathJoin(dirName, fileName));
                    }
                }
            }
        }
    }

    void getDirs(FsEntry *restrict const entry,
                 std::string dirName,
                 StringVect &names)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        const std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
            dirName = pathJoin(subDir, dirName);
        if (dirName == dirSeparator)
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                // skip subdirs from enumeration
                const size_t idx = fileName.find(dirSeparator);
                if (idx != std::string::npos)
                    fileName.erase(idx);
                bool found(false);
                FOR_EACH (StringVectCIter, itn, names)
                {
                    if (*itn == fileName)
                    {
                        found = true;
                        break;
                    }
                }
                if (found == false)
                {
                    std::string dirName2 = pathJoin(dirName, fileName);
                    if (findLast(dirName2, std::string(dirSeparator)) == false)
                        dirName2 += dirSeparator;
                    FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                              it,
                              zipEntry->mDirs)
                    {
                        if (*it == dirName2)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == true)
                        names.push_back(fileName);
                }
            }
        }
        else
        {
            FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                      it2,
                      zipEntry->mHeaders)
            {
                ZipLocalHeader *const header = *it2;
                std::string fileName = header->fileName;
                if (findCutFirst(fileName, dirName) == true)
                {
                    // skip subdirs from enumeration
                    const size_t idx = fileName.find(dirSeparator);
                    if (idx != std::string::npos)
                        fileName.erase(idx);
                    bool found(false);
                    FOR_EACH (StringVectCIter, itn, names)
                    {
                        if (*itn == fileName)
                        {
                            found = true;
                            break;
                        }
                    }
                    if (found == false)
                    {
                        std::string dirName2 = pathJoin(dirName, fileName);
                        if (findLast(dirName2, std::string(dirSeparator)) ==
                            false)
                        {
                            dirName2 += dirSeparator;
                        }
                        FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                                  it,
                                  zipEntry->mDirs)
                        {
                            if (*it == dirName2)
                            {
                                found = true;
                                break;
                            }
                        }
                        if (found == true)
                            names.push_back(fileName);
                    }
                }
            }
        }
    }

    bool isDirectory(FsEntry *restrict const entry,
                     std::string dirName,
                     bool &isDirFlag)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
            dirName = pathJoin(subDir, dirName);
        FOR_EACH (STD_VECTOR<std::string>::const_iterator,
                  it2,
                  zipEntry->mDirs)
        {
            if (*it2 == dirName)
            {
                isDirFlag = true;
                return true;
            }
        }
        return false;
    }

    void freeList(List *restrict const handle)
    {
        delete handle;
    }

    File *openRead(FsEntry *restrict const entry,
                   std::string filename)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
            filename = pathJoin(subDir, filename);
        FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                  it2,
                  zipEntry->mHeaders)
        {
            const ZipLocalHeader *restrict const header = *it2;
            if (header->fileName == filename)
            {
                const uint8_t *restrict const buf =
                    ZipReader::readFile(header);
                if (buf == nullptr)
                    return nullptr;
                return new File(&funcs,
                    buf,
                    header->uncompressSize);
            }
        }
        return nullptr;
    }

    File *openWrite(FsEntry *restrict const entry A_UNUSED,
                    const std::string &filename A_UNUSED)
    {
        reportAlways("VirtFs::openWrite for zip not implemented.")
        return nullptr;
    }

    File *openAppend(FsEntry *restrict const entry A_UNUSED,
                     const std::string &filename A_UNUSED)
    {
        reportAlways("VirtFs::openAppend for zip not implemented.")
        return nullptr;
    }

    int close(File *restrict const file)
    {
        if (file == nullptr)
            return 0;
        delete file;
        return 1;
    }

    int64_t read(File *restrict const file,
                 void *restrict const buffer,
                 const uint32_t objSize,
                 const uint32_t objCount)
    {
        if (file == nullptr ||
            objSize == 0 ||
            objCount == 0)
        {
            return 0;
        }
        if (buffer == nullptr)
        {
            reportAlways("FsZip::read buffer is null")
            return 0;
        }
        const size_t pos = file->mPos;
        const size_t sz = file->mSize;
        // if outside of buffer, return
        if (pos >= sz)
            return 0;
        // pointer to start for buffer ready to read
        const uint8_t *restrict const memPtr = file->mBuf + pos;
        // left buffer size from pos to end
        const uint32_t memSize = CAST_U32(sz - pos);
        // number of objects possible to read
        uint32_t memCount = memSize / objSize;
        if (memCount == 0)
            return 0;
        // limit number of possible objects to read to objCount
        if (memCount > objCount)
            memCount = objCount;
        // number of bytes to read from buffer
        const size_t memEnd = memCount * objSize;
        memcpy(buffer, memPtr, memEnd);
        file->mPos += memEnd;
        return memCount;
    }

    int64_t write(File *restrict const file A_UNUSED,
                  const void *restrict const buffer A_UNUSED,
                  const uint32_t objSize A_UNUSED,
                  const uint32_t objCount A_UNUSED)
    {
        return 0;
    }

    int64_t fileLength(File *restrict const file)
    {
        if (file == nullptr)
            return -1;

        return file->mSize;
    }

    int64_t tell(File *restrict const file)
    {
        if (file == nullptr)
            return -1;

        return file->mPos;
    }

    int seek(File *restrict const file,
             const uint64_t pos)
    {
        if (file == nullptr)
            return 0;

        if (pos > file->mSize)
            return 0;
        file->mPos = pos;
        return 1;
    }

    int eof(File *restrict const file)
    {
        if (file == nullptr)
            return -1;

        return static_cast<int>(file->mPos >= file->mSize);
    }

    const char *loadFile(FsEntry *restrict const entry,
                         std::string filename,
                         int &restrict fileSize)
    {
        ZipEntry *const zipEntry = static_cast<ZipEntry*>(entry);
        const std::string subDir = zipEntry->subDir;
        if (!subDir.empty())
            filename = pathJoin(subDir, filename);
        FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
                  it2,
                  zipEntry->mHeaders)
        {
            const ZipLocalHeader *restrict const header = *it2;
            if (header->fileName == filename)
            {
                const uint8_t *restrict const buf =
                    ZipReader::readFile(header);
                if (buf == nullptr)
                    return nullptr;

                logger->log("Loaded %s/%s",
                    entry->root.c_str(),
                    filename.c_str());

                fileSize = header->uncompressSize;
                return reinterpret_cast<const char*>(buf);
            }
        }
        return nullptr;
    }
}  // namespace FsZip

}  // namespace VirtFs


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			* The ManaPlus Client
3			* Copyright (C) 2013-2019 The ManaPlus Developers
4			* Copyright (C) 2019-2021 Andrei Karas
5			*
6			* This file is part of The ManaPlus Client.
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program. If not, see <http://www.gnu.org/licenses/>.
20			*/
21
22			#include "fs/virtfs/fszip.h"
23
24			#include "fs/virtfs/file.h"
25			#include "fs/virtfs/fsfuncs.h"
26			#include "fs/virtfs/fsziprwops.h"
27			#include "fs/virtfs/list.h"
28			#include "fs/virtfs/zipentry.h"
29			#include "fs/virtfs/zipreader.h"
30			#include "fs/virtfs/ziplocalheader.h"
31
32			#include "utils/cast.h"
33			#include "utils/checkutils.h"
34			#include "utils/foreach.h"
35			#include "utils/stringutils.h"
36
37			#include "debug.h"
38
39			extern const char *dirSeparator;
40
41			namespace
42			{
43			VirtFs::FsFuncs funcs;
44			} // namespace
45
46			namespace VirtFs
47			{
48
49			namespace FsZip
50			{
51		103	FsFuncs *getFuncs()
52			{
53		103	return &funcs;
54			}
55
56		119	void deinit()
57			{
58		119	}
59
60		120	void init()
61			{
62		120	initFuncs(&funcs);
63		120	}
64
65			void initFuncs(FsFuncs *restrict const ptr)
66			{
67		120	ptr->close = &FsZip::close;
68		120	ptr->read = &FsZip::read;
69		120	ptr->write = &FsZip::write;
70		120	ptr->fileLength = &FsZip::fileLength;
71		120	ptr->tell = &FsZip::tell;
72		120	ptr->seek = &FsZip::seek;
73		120	ptr->eof = &FsZip::eof;
74		120	ptr->exists = &FsZip::exists;
75		120	ptr->getRealDir = &FsZip::getRealDir;
76		120	ptr->enumerate = &FsZip::enumerate;
77		120	ptr->isDirectory = &FsZip::isDirectory;
78		120	ptr->openRead = &FsZip::openRead;
79		120	ptr->openWrite = &FsZip::openWrite;
80		120	ptr->openAppend = &FsZip::openAppend;
81		120	ptr->loadFile = &FsZip::loadFile;
82		120	ptr->getFiles = &FsZip::getFiles;
83		120	ptr->getFilesWithDir = &FsZip::getFilesWithDir;
84		120	ptr->getDirs = &FsZip::getDirs;
85		120	ptr->rwops_seek = &FsZip::rwops_seek;
86		120	ptr->rwops_read = &FsZip::rwops_read;
87		120	ptr->rwops_write = &FsZip::rwops_write;
88		120	ptr->rwops_close = &FsZip::rwops_close;
89			#ifdef USE_SDL2
90		120	ptr->rwops_size = &FsZip::rwops_size;
91			#endif // USE_SDL2
92			}
93
94		27	bool getRealDir(FsEntry *restrict const entry,
95			std::string filename,
96			std::string dirName,
97			std::string &realDir)
98			{
99		27	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
100		81	std::string subDir = zipEntry->subDir;
101	✓✓	27	if (!subDir.empty())
102			{
103	✓✗	6	filename = pathJoin(subDir, filename);
104	✓✗	6	dirName = pathJoin(subDir, dirName);
105			}
106	✓✓	319	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
107			it2,
108			zipEntry->mHeaders)
109			{
110	✓✓	169	if ((*it2)->fileName == filename)
111			{
112		12	realDir = entry->root;
113			return true;
114			}
115			}
116	✓✓	130	FOR_EACH (STD_VECTOR<std::string>::const_iterator,
117			it2,
118			zipEntry->mDirs)
119			{
120	✓✓	41	if (*it2 == dirName)
121			{
122		1	realDir = entry->root;
123			return true;
124			}
125			}
126			return false;
127			}
128
129		52	bool exists(FsEntry *restrict const entry,
130			std::string filename,
131			std::string dirName)
132			{
133		52	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
134		156	std::string subDir = zipEntry->subDir;
135	✓✓	52	if (!subDir.empty())
136			{
137	✓✗	39	filename = pathJoin(subDir, filename);
138	✓✗	39	dirName = pathJoin(subDir, dirName);
139			}
140	✓✓	663	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
141			it2,
142			zipEntry->mHeaders)
143			{
144	✓✓	365	if ((*it2)->fileName == filename)
145			return true;
146			}
147	✓✓	336	FOR_EACH (STD_VECTOR<std::string>::const_iterator,
148			it2,
149			zipEntry->mDirs)
150			{
151	✓✓	112	if (*it2 == dirName)
152			return true;
153			}
154			return false;
155			}
156
157		12	void enumerate(FsEntry *restrict const entry,
158			std::string dirName,
159			StringVect &names)
160			{
161		12	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
162		36	const std::string subDir = zipEntry->subDir;
163	✓✓	12	if (!subDir.empty())
164	✓✗	6	dirName = pathJoin(subDir, dirName);
165	✓✓	24	if (dirName == dirSeparator)
166			{
167	✓✓	50	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
168			it2,
169			zipEntry->mHeaders)
170			{
171		26	ZipLocalHeader const header = it2;
172		78	std::string fileName = header->fileName;
173			// skip subdirs from enumeration
174		52	const size_t idx = fileName.find(dirSeparator);
175	✓✓	26	if (idx != std::string::npos)
176	✓✗	22	fileName.erase(idx);
177		26	bool found(false);
178	✓✓	164	FOR_EACH (StringVectCIter, itn, names)
179			{
180	✓✓	50	if (*itn == fileName)
181			{
182			found = true;
183			break;
184			}
185			}
186	✓✓	26	if (found == false)
187	✓✗	10	names.push_back(fileName);
188			}
189			}
190			else
191			{
192	✓✓	109	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
193			it2,
194			zipEntry->mHeaders)
195			{
196		61	ZipLocalHeader const header = it2;
197		183	std::string fileName = header->fileName;
198	✓✗✓✓	61	if (findCutFirst(fileName, dirName) == true)
199			{
200			// skip subdirs from enumeration
201		52	const size_t idx = fileName.find(dirSeparator);
202	✓✓	26	if (idx != std::string::npos)
203	✓✗	6	fileName.erase(idx);
204		26	bool found(false);
205	✓✓	212	FOR_EACH (StringVectCIter, itn, names)
206			{
207	✓✓	85	if (*itn == fileName)
208			{
209			found = true;
210			break;
211			}
212			}
213	✓✓	26	if (found == false)
214	✓✗	23	names.push_back(fileName);
215			}
216			}
217			}
218		12	}
219
220		4	void getFiles(FsEntry *restrict const entry,
221			std::string dirName,
222			StringVect &names)
223			{
224		4	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
225		12	const std::string subDir = zipEntry->subDir;
226	✓✓	4	if (!subDir.empty())
227	✓✗	6	dirName = pathJoin(subDir, dirName);
228	✗✓	8	if (dirName == dirSeparator)
229			{
230			FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
231			it2,
232			zipEntry->mHeaders)
233			{
234			ZipLocalHeader const header = it2;
235			std::string fileName = header->fileName;
236			// skip subdirs from enumeration
237			const size_t idx = fileName.find(dirSeparator);
238			if (idx != std::string::npos)
239			fileName.erase(idx);
240			bool found(false);
241			FOR_EACH (StringVectCIter, itn, names)
242			{
243			if (*itn == fileName)
244			{
245			found = true;
246			break;
247			}
248			}
249			if (found == false)
250			{
251			std::string dirName2 = pathJoin(dirName, fileName);
252			if (findLast(dirName2, std::string(dirSeparator)) == false)
253			dirName2 += dirSeparator;
254			FOR_EACH (STD_VECTOR<std::string>::const_iterator,
255			it,
256			zipEntry->mDirs)
257			{
258			if (*it == dirName2)
259			{
260			found = true;
261			break;
262			}
263			}
264			if (found == false)
265			names.push_back(fileName);
266			}
267			}
268			}
269			else
270			{
271	✓✓	68	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
272			it2,
273			zipEntry->mHeaders)
274			{
275		44	ZipLocalHeader const header = it2;
276		132	std::string fileName = header->fileName;
277	✓✗✓✓	44	if (findCutFirst(fileName, dirName) == true)
278			{
279			// skip subdirs from enumeration
280		32	const size_t idx = fileName.find(dirSeparator);
281	✓✓	16	if (idx != std::string::npos)
282	✓✗	6	fileName.erase(idx);
283		16	bool found(false);
284	✓✓	95	FOR_EACH (StringVectCIter, itn, names)
285			{
286	✓✗	15	if (*itn == fileName)
287			{
288			found = true;
289			break;
290			}
291			}
292	✓✗	16	if (found == false)
293			{
294	✓✗	48	std::string dirName2 = pathJoin(dirName, fileName);
295	✓✗✓✗ ✓✗	64	if (findLast(dirName2, std::string(dirSeparator)) ==
296			false)
297			{
298		16	dirName2 += dirSeparator;
299			}
300	✓✓	150	FOR_EACH (STD_VECTOR<std::string>::const_iterator,
301			it,
302			zipEntry->mDirs)
303			{
304	✓✓	60	if (*it == dirName2)
305			{
306			found = true;
307			break;
308			}
309			}
310	✓✓	16	if (found == false)
311	✓✗	10	names.push_back(fileName);
312			}
313			}
314			}
315			}
316		4	}
317
318		5	void getFilesWithDir(FsEntry *restrict const entry,
319			const std::string &dirName,
320			StringVect &names)
321			{
322		5	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
323		15	const std::string subDir = zipEntry->subDir;
324		10	std::string dirNameFull;
325	✓✓	5	if (!subDir.empty())
326	✓✗	6	dirNameFull = pathJoin(subDir, dirName);
327			else
328			dirNameFull = dirName;
329	✓✓	10	if (dirNameFull == dirSeparator)
330			{
331	✓✓	17	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
332			it2,
333			zipEntry->mHeaders)
334			{
335		11	ZipLocalHeader const header = it2;
336		33	std::string fileName = header->fileName;
337			// skip subdirs from enumeration
338		22	const size_t idx = fileName.find(dirSeparator);
339	✓✓	11	if (idx != std::string::npos)
340	✓✗	9	fileName.erase(idx);
341		11	bool found(false);
342	✓✓	110	FOR_EACH (StringVectCIter, itn, names)
343			{
344	✓✗	55	if (*itn == fileName)
345			{
346			found = true;
347			break;
348			}
349			}
350	✓✗	11	if (found == false)
351			{
352	✓✗	33	std::string dirName2 = pathJoin(dirNameFull, fileName);
353	✓✗✓✗ ✓✗	44	if (findLast(dirName2, std::string(dirSeparator)) == false)
354		11	dirName2 += dirSeparator;
355	✓✓	110	FOR_EACH (STD_VECTOR<std::string>::const_iterator,
356			it,
357			zipEntry->mDirs)
358			{
359	✓✗	44	if (*it == dirName2)
360			{
361			found = true;
362			break;
363			}
364			}
365	✓✗	11	if (found == false)
366	✓✗	44	names.push_back(pathJoin(dirName, fileName));
367			}
368			}
369			}
370			else
371			{
372	✓✓	68	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
373			it2,
374			zipEntry->mHeaders)
375			{
376		44	ZipLocalHeader const header = it2;
377		132	std::string fileName = header->fileName;
378	✓✗✓✓	44	if (findCutFirst(fileName, dirNameFull) == true)
379			{
380			// skip subdirs from enumeration
381		32	const size_t idx = fileName.find(dirSeparator);
382	✓✓	16	if (idx != std::string::npos)
383	✓✗	6	fileName.erase(idx);
384		16	bool found(false);
385	✓✓	95	FOR_EACH (StringVectCIter, itn, names)
386			{
387	✓✗	15	if (*itn == fileName)
388			{
389			found = true;
390			break;
391			}
392			}
393	✓✗	16	if (found == false)
394			{
395	✓✗	48	std::string dirName2 = pathJoin(dirNameFull, fileName);
396	✓✗✓✗ ✓✗	64	if (findLast(dirName2, std::string(dirSeparator)) ==
397			false)
398			{
399		16	dirName2 += dirSeparator;
400			}
401	✓✓	150	FOR_EACH (STD_VECTOR<std::string>::const_iterator,
402			it,
403			zipEntry->mDirs)
404			{
405	✓✓	60	if (*it == dirName2)
406			{
407			found = true;
408			break;
409			}
410			}
411	✓✓	16	if (found == false)
412	✓✗	40	names.push_back(pathJoin(dirName, fileName));
413			}
414			}
415			}
416			}
417		5	}
418
419		4	void getDirs(FsEntry *restrict const entry,
420			std::string dirName,
421			StringVect &names)
422			{
423		4	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
424		12	const std::string subDir = zipEntry->subDir;
425	✓✓	4	if (!subDir.empty())
426	✓✗	6	dirName = pathJoin(subDir, dirName);
427	✗✓	8	if (dirName == dirSeparator)
428			{
429			FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
430			it2,
431			zipEntry->mHeaders)
432			{
433			ZipLocalHeader const header = it2;
434			std::string fileName = header->fileName;
435			// skip subdirs from enumeration
436			const size_t idx = fileName.find(dirSeparator);
437			if (idx != std::string::npos)
438			fileName.erase(idx);
439			bool found(false);
440			FOR_EACH (StringVectCIter, itn, names)
441			{
442			if (*itn == fileName)
443			{
444			found = true;
445			break;
446			}
447			}
448			if (found == false)
449			{
450			std::string dirName2 = pathJoin(dirName, fileName);
451			if (findLast(dirName2, std::string(dirSeparator)) == false)
452			dirName2 += dirSeparator;
453			FOR_EACH (STD_VECTOR<std::string>::const_iterator,
454			it,
455			zipEntry->mDirs)
456			{
457			if (*it == dirName2)
458			{
459			found = true;
460			break;
461			}
462			}
463			if (found == true)
464			names.push_back(fileName);
465			}
466			}
467			}
468			else
469			{
470	✓✓	68	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
471			it2,
472			zipEntry->mHeaders)
473			{
474		44	ZipLocalHeader const header = it2;
475		132	std::string fileName = header->fileName;
476	✓✗✓✓	44	if (findCutFirst(fileName, dirName) == true)
477			{
478			// skip subdirs from enumeration
479		32	const size_t idx = fileName.find(dirSeparator);
480	✓✓	16	if (idx != std::string::npos)
481	✓✗	6	fileName.erase(idx);
482		16	bool found(false);
483	✓✓	86	FOR_EACH (StringVectCIter, itn, names)
484			{
485	✓✓	8	if (*itn == fileName)
486			{
487			found = true;
488			break;
489			}
490			}
491	✓✓	16	if (found == false)
492			{
493	✓✗	42	std::string dirName2 = pathJoin(dirName, fileName);
494	✓✗✓✗ ✓✗	56	if (findLast(dirName2, std::string(dirSeparator)) ==
495			false)
496			{
497		14	dirName2 += dirSeparator;
498			}
499	✓✓	134	FOR_EACH (STD_VECTOR<std::string>::const_iterator,
500			it,
501			zipEntry->mDirs)
502			{
503	✓✓	54	if (*it == dirName2)
504			{
505			found = true;
506			break;
507			}
508			}
509	✓✓	14	if (found == true)
510	✓✗	4	names.push_back(fileName);
511			}
512			}
513			}
514			}
515		4	}
516
517		113	bool isDirectory(FsEntry *restrict const entry,
518			std::string dirName,
519			bool &isDirFlag)
520			{
521		113	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
522		339	std::string subDir = zipEntry->subDir;
523	✓✓	113	if (!subDir.empty())
524	✓✗	51	dirName = pathJoin(subDir, dirName);
525	✓✓	944	FOR_EACH (STD_VECTOR<std::string>::const_iterator,
526			it2,
527			zipEntry->mDirs)
528			{
529	✓✓	291	if (*it2 == dirName)
530			{
531		25	isDirFlag = true;
532		25	return true;
533			}
534			}
535			return false;
536			}
537
538			void freeList(List *restrict const handle)
539			{
540			delete handle;
541			}
542
543		88	File openRead(FsEntry restrict const entry,
544			std::string filename)
545			{
546		88	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
547		264	std::string subDir = zipEntry->subDir;
548	✓✓	88	if (!subDir.empty())
549	✓✗	81	filename = pathJoin(subDir, filename);
550	✓✓	1047	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
551			it2,
552			zipEntry->mHeaders)
553			{
554		563	const ZipLocalHeader restrict const header = it2;
555	✓✓	563	if (header->fileName == filename)
556			{
557			const uint8_t *restrict const buf =
558	✓✗	44	ZipReader::readFile(header);
559	✓✗	44	if (buf == nullptr)
560			return nullptr;
561			return new File(&funcs,
562			buf,
563	✓✗✓✗	44	header->uncompressSize);
564			}
565			}
566			return nullptr;
567			}
568
569			File openWrite(FsEntry restrict const entry A_UNUSED,
570			const std::string &filename A_UNUSED)
571			{
572			reportAlways("VirtFs::openWrite for zip not implemented.")
573			return nullptr;
574			}
575
576			File openAppend(FsEntry restrict const entry A_UNUSED,
577			const std::string &filename A_UNUSED)
578			{
579			reportAlways("VirtFs::openAppend for zip not implemented.")
580			return nullptr;
581			}
582
583		29	int close(File *restrict const file)
584			{
585	✓✗	29	if (file == nullptr)
586			return 0;
587		29	delete file;
588		29	return 1;
589			}
590
591		230	int64_t read(File *restrict const file,
592			void *restrict const buffer,
593			const uint32_t objSize,
594			const uint32_t objCount)
595			{
596	✓✗	460	if (file == nullptr \|\|
597	✓✗	460	objSize == 0 \|\|
598			objCount == 0)
599			{
600			return 0;
601			}
602	✗✓	230	if (buffer == nullptr)
603			{
604			reportAlways("FsZip::read buffer is null")
605			return 0;
606			}
607		230	const size_t pos = file->mPos;
608		230	const size_t sz = file->mSize;
609			// if outside of buffer, return
610	✓✗	230	if (pos >= sz)
611			return 0;
612			// pointer to start for buffer ready to read
613		230	const uint8_t *restrict const memPtr = file->mBuf + pos;
614			// left buffer size from pos to end
615		230	const uint32_t memSize = CAST_U32(sz - pos);
616			// number of objects possible to read
617		230	uint32_t memCount = memSize / objSize;
618	✓✓	230	if (memCount == 0)
619			return 0;
620			// limit number of possible objects to read to objCount
621	✓✓	228	if (memCount > objCount)
622		203	memCount = objCount;
623			// number of bytes to read from buffer
624		228	const size_t memEnd = memCount * objSize;
625		228	memcpy(buffer, memPtr, memEnd);
626		228	file->mPos += memEnd;
627		228	return memCount;
628			}
629
630			int64_t write(File *restrict const file A_UNUSED,
631			const void *restrict const buffer A_UNUSED,
632			const uint32_t objSize A_UNUSED,
633			const uint32_t objCount A_UNUSED)
634			{
635			return 0;
636			}
637
638		14	int64_t fileLength(File *restrict const file)
639			{
640	✓✗	14	if (file == nullptr)
641			return -1;
642
643		14	return file->mSize;
644			}
645
646		78	int64_t tell(File *restrict const file)
647			{
648	✓✗	78	if (file == nullptr)
649			return -1;
650
651		78	return file->mPos;
652			}
653
654		27	int seek(File *restrict const file,
655			const uint64_t pos)
656			{
657	✓✗	27	if (file == nullptr)
658			return 0;
659
660	✓✗	27	if (pos > file->mSize)
661			return 0;
662		27	file->mPos = pos;
663		27	return 1;
664			}
665
666		84	int eof(File *restrict const file)
667			{
668	✓✗	84	if (file == nullptr)
669			return -1;
670
671		84	return static_cast<int>(file->mPos >= file->mSize);
672			}
673
674		4	const char loadFile(FsEntry restrict const entry,
675			std::string filename,
676			int &restrict fileSize)
677			{
678		4	ZipEntry const zipEntry = static_cast<ZipEntry>(entry);
679		12	const std::string subDir = zipEntry->subDir;
680	✓✓	4	if (!subDir.empty())
681	✓✗	6	filename = pathJoin(subDir, filename);
682	✓✗	32	FOR_EACH (STD_VECTOR<ZipLocalHeader*>::const_iterator,
683			it2,
684			zipEntry->mHeaders)
685			{
686		12	const ZipLocalHeader restrict const header = it2;
687	✓✓	12	if (header->fileName == filename)
688			{
689			const uint8_t *restrict const buf =
690	✓✗	4	ZipReader::readFile(header);
691	✓✗	4	if (buf == nullptr)
692			return nullptr;
693
694		8	logger->log("Loaded %s/%s",
695			entry->root.c_str(),
696	✓✗	4	filename.c_str());
697
698		4	fileSize = header->uncompressSize;
699		4	return reinterpret_cast<const char*>(buf);
700			}
701			}
702			return nullptr;
703			}
704			} // namespace FsZip
705
706	✓✗✓✗	3	} // namespace VirtFs