[vfs #1] Add ttvfs, miniz, and minihttp sources

ExternalLibs/ttvfs_zip/VFSFileZip.cpp

@@ -0,0 +1,197 @@
+#include "VFSFileZip.h"
+#include "VFSInternal.h"
+#include "VFSTools.h"
+#include "VFSDir.h"
+
+VFS_NAMESPACE_START
+
+// From miniz.c
+//#define MZ_ZIP_MODE_READING 2
+
+
+static bool zip_reader_reopen_vfsfile(mz_zip_archive *pZip, mz_uint32 flags)
+{
+    if(!(pZip && pZip->m_pIO_opaque && pZip->m_pRead))
+        return false;
+    VFSFile *vf = (VFSFile*)pZip->m_pIO_opaque;
+    if(!vf->isopen())
+        if(!vf->open("rb"))
+            return false;
+    if(pZip->m_zip_mode == MZ_ZIP_MODE_READING)
+        return true;
+    mz_uint64 file_size = vf->size();
+    if(!file_size)
+    {
+        vf->close();
+        return false;
+    }
+    if (!mz_zip_reader_init(pZip, file_size, flags))
+    {
+        vf->close();
+        return false;
+    }
+    return true;
+}
+
+
+VFSFileZip::VFSFileZip(mz_zip_archive *zip)
+: VFSFile(NULL), _fixedStr(NULL), _zip(zip)
+{
+    _mode = "b"; // binary mode by default
+    _pos = 0;
+}
+
+void VFSFileZip::_init()
+{
+    _setName(_zipstat.m_filename);
+}
+
+VFSFileZip::~VFSFileZip()
+{
+    dropBuf(true);
+}
+
+bool VFSFileZip::open(const char *mode /* = NULL */)
+{
+    VFS_GUARD_OPT(this);
+
+    _pos = 0;
+    if(mode)
+    {
+        if(_fixedStr && _mode != mode)
+        {
+            delete [] _fixedStr;
+            _fixedStr = NULL;
+        }
+
+        _mode = mode;
+    }
+    return true; // does not have to be opened
+}
+
+bool VFSFileZip::isopen(void) const
+{
+    return true; // is always open
+}
+
+bool VFSFileZip::iseof(void) const
+{
+    VFS_GUARD_OPT(this);
+    return _pos >= _zipstat.m_uncomp_size;
+}
+
+bool VFSFileZip::close(void)
+{
+    //return flush(); // TODO: write to zip file on close
+
+    return true;
+}
+
+bool VFSFileZip::seek(vfspos pos)
+{
+    if(pos >= 0xFFFFFFFF) // zip files have uint32 range only
+        return false;
+
+    VFS_GUARD_OPT(this);
+    _pos = (unsigned int)pos;
+    return true;
+}
+
+bool VFSFileZip::flush(void)
+{
+    // FIXME: use this to actually write to zip file?
+    return false;
+}
+
+vfspos VFSFileZip::getpos(void) const
+{
+    VFS_GUARD_OPT(this);
+    return _pos;
+}
+
+unsigned int VFSFileZip::read(void *dst, unsigned int bytes)
+{
+    VFS_GUARD_OPT(this);
+    char *mem = (char*)getBuf();
+    char *startptr = mem + _pos;
+    char *endptr = mem + size();
+    bytes = std::min((unsigned int)(endptr - startptr), bytes); // limit in case reading over buffer size
+    if(_mode.find('b') == std::string::npos)
+        strnNLcpy((char*)dst, (const char*)startptr, bytes); // non-binary == text mode
+    else
+        memcpy(dst, startptr, bytes); //  binary copy
+    _pos += bytes;
+    return bytes;
+}
+
+unsigned int VFSFileZip::write(const void *src, unsigned int bytes)
+{
+    /*VFS_GUARD_OPT(this);
+    if(getpos() + bytes >= size())
+        size(getpos() + bytes); // enlarge if necessary
+
+    memcpy(_buf + getpos(), src, bytes);
+
+    // TODO: implement actually writing to the Zip file.
+
+    return bytes;*/
+
+    return VFSFile::write(src, bytes);
+}
+
+vfspos VFSFileZip::size(void)
+{
+    VFS_GUARD_OPT(this);
+    return (vfspos)_zipstat.m_uncomp_size;
+}
+
+const void *VFSFileZip::getBuf(allocator_func alloc /* = NULL */, delete_func del /* = NULL */)
+{
+    assert(!alloc == !del); // either both or none may be defined. Checked extra early to prevent possible errors later.
+
+    VFS_GUARD_OPT(this);
+    // _fixedStr gets deleted on mode change, so doing this check here is fine
+    if(_fixedStr)
+        return _fixedStr;
+
+    if(!_buf)
+    {
+        size_t sz = (size_t)size();
+        _buf = allocHelperExtra(alloc, sz, 4);
+        if(!_buf)
+            return NULL;
+        _delfunc = del;
+
+        if(!zip_reader_reopen_vfsfile(_zip, 0))
+            return false; // can happen if the underlying zip file was deleted
+        if(!mz_zip_reader_extract_to_mem(_zip, _zipstat.m_file_index, _buf, sz, 0))
+            return false; // this should not happen
+
+        if(_mode.find("b") == std::string::npos) // text mode?
+        {
+            _fixedStr = allocHelperExtra(alloc, sz, 4);
+            strnNLcpy(_fixedStr, (const char*)_buf);
+
+            // FIXME: is this really correct?
+            VFSFile::dropBuf(true);
+
+            return _fixedStr;
+        }
+
+    }
+
+    return _buf;
+}
+
+void VFSFileZip::dropBuf(bool del)
+{
+    VFSFile::dropBuf(del);
+
+    VFS_GUARD_OPT(this);
+    if(del)
+        delBuf(_fixedStr);
+    _fixedStr = NULL;
+
+}
+
+VFS_NAMESPACE_END