diff options
| -rw-r--r-- | src/common/src/chunk_file.h | 756 |
1 files changed, 623 insertions, 133 deletions
diff --git a/src/common/src/chunk_file.h b/src/common/src/chunk_file.h index 0c333b094..c480bc8ea 100644 --- a/src/common/src/chunk_file.h +++ b/src/common/src/chunk_file.h @@ -1,7 +1,19 @@ -// Copyright 2013 Dolphin Emulator Project -// Licensed under GPLv2 -// Refer to the license.txt file included. +// Copyright (C) 2003 Dolphin Project. +// 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, version 2.0 or later versions. + +// 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 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official SVN repository and contact information can be found at +// http://code.google.com/p/dolphin-emu/ #ifndef _POINTERWRAP_H_ #define _POINTERWRAP_H_ @@ -17,13 +29,39 @@ #include <map> #include <vector> -#include <list> #include <deque> #include <string> +#include <list> +#include <set> +#ifndef __SYMBIAN32__ +#if defined(IOS) || defined(MACGNUSTD) +#include <tr1/type_traits> +#else #include <type_traits> +#endif +#endif #include "common.h" #include "file_util.h" +//#include "../ext/snappy/snappy-c.h" + +#if defined(IOS) || defined(MACGNUSTD) +namespace std { + using tr1::is_pointer; +} +#endif +#ifdef __SYMBIAN32__ +namespace std { + template <bool bool_value> + struct bool_constant { + typedef bool_constant<bool_value> type; + static const bool value = bool_value; + }; + template <bool bool_value> const bool bool_constant<bool_value>::value; + template <typename T> struct is_pointer : public bool_constant<false> {}; + template <typename T> struct is_pointer<T*> : public bool_constant<true> {}; +} +#endif template <class T> struct LinkedListItem : public T @@ -31,118 +69,505 @@ struct LinkedListItem : public T LinkedListItem<T> *next; }; +class PointerWrap; + +class PointerWrapSection +{ +public: + PointerWrapSection(PointerWrap &p, int ver, const char *title) : p_(p), ver_(ver), title_(title) { + } + ~PointerWrapSection(); + + bool operator == (const int &v) const { return ver_ == v; } + bool operator != (const int &v) const { return ver_ != v; } + bool operator <= (const int &v) const { return ver_ <= v; } + bool operator >= (const int &v) const { return ver_ >= v; } + bool operator < (const int &v) const { return ver_ < v; } + bool operator > (const int &v) const { return ver_ > v; } + + operator bool() const { + return ver_ > 0; + } + +private: + PointerWrap &p_; + int ver_; + const char *title_; +}; + // Wrapper class class PointerWrap { -public: - enum Mode + // This makes it a compile error if you forget to define DoState() on non-POD. + // Which also can be a problem, for example struct tm is non-POD on linux, for whatever reason... +#ifdef _MSC_VER + template<typename T, bool isPOD = std::is_pod<T>::value, bool isPointer = std::is_pointer<T>::value> +#else + template<typename T, bool isPOD = __is_pod(T), bool isPointer = std::is_pointer<T>::value> +#endif + struct DoHelper { + static void DoArray(PointerWrap *p, T *x, int count) + { + for (int i = 0; i < count; ++i) + p->Do(x[i]); + } + + static void Do(PointerWrap *p, T &x) + { + p->DoClass(x); + } + }; + + template<typename T> + struct DoHelper<T, true, false> + { + static void DoArray(PointerWrap *p, T *x, int count) + { + p->DoVoid((void *)x, sizeof(T) * count); + } + + static void Do(PointerWrap *p, T &x) + { + p->DoVoid((void *)&x, sizeof(x)); + } + }; + +public: + enum Mode { MODE_READ = 1, // load MODE_WRITE, // save MODE_MEASURE, // calculate size MODE_VERIFY, // compare }; + enum Error { + ERROR_NONE = 0, + ERROR_WARNING = 1, + ERROR_FAILURE = 2, + }; + u8 **ptr; Mode mode; + Error error; public: - PointerWrap(u8 **ptr_, Mode mode_) : ptr(ptr_), mode(mode_) {} + PointerWrap(u8 **ptr_, Mode mode_) : ptr(ptr_), mode(mode_), error(ERROR_NONE) {} + PointerWrap(unsigned char **ptr_, int mode_) : ptr((u8**)ptr_), mode((Mode)mode_), error(ERROR_NONE) {} + + PointerWrapSection Section(const char *title, int ver) { + return Section(title, ver, ver); + } - void SetMode(Mode mode_) { mode = mode_; } - Mode GetMode() const { return mode; } - u8** GetPPtr() { return ptr; } + // The returned object can be compared against the version that was loaded. + // This can be used to support versions as old as minVer. + // Version = 0 means the section was not found. + PointerWrapSection Section(const char *title, int minVer, int ver) { + char marker[16] = {0}; + int foundVersion = ver; - template <typename K, class V> - void Do(std::map<K, V>& x) + strncpy(marker, title, sizeof(marker)); + if (!ExpectVoid(marker, sizeof(marker))) + { + // Might be before we added name markers for safety. + if (foundVersion == 1 && ExpectVoid(&foundVersion, sizeof(foundVersion))) + DoMarker(title); + // Wasn't found, but maybe we can still load the state. + else + foundVersion = 0; + } + else + Do(foundVersion); + + if (error == ERROR_FAILURE || foundVersion < minVer || foundVersion > ver) { + WARN_LOG(COMMON, "Savestate failure: wrong version %d found for %s", foundVersion, title); + SetError(ERROR_FAILURE); + return PointerWrapSection(*this, -1, title); + } + return PointerWrapSection(*this, foundVersion, title); + } + + void SetMode(Mode mode_) {mode = mode_;} + Mode GetMode() const {return mode;} + u8 **GetPPtr() {return ptr;} + void SetError(Error error_) { - u32 count = (u32)x.size(); - Do(count); + if (error < error_) + error = error_; + if (error > ERROR_WARNING) + mode = PointerWrap::MODE_MEASURE; + } - switch (mode) + bool ExpectVoid(void *data, int size) + { + switch (mode) { + case MODE_READ: if (memcmp(data, *ptr, size) != 0) return false; break; + case MODE_WRITE: memcpy(*ptr, data, size); break; + case MODE_MEASURE: break; // MODE_MEASURE - don't need to do anything + case MODE_VERIFY: for(int i = 0; i < size; i++) _dbg_assert_msg_(COMMON, ((u8*)data)[i] == (*ptr)[i], "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i], &(*ptr)[i]); break; + default: break; // throw an error? + } + (*ptr) += size; + return true; + } + + void DoVoid(void *data, int size) + { + switch (mode) { + case MODE_READ: memcpy(data, *ptr, size); break; + case MODE_WRITE: memcpy(*ptr, data, size); break; + case MODE_MEASURE: break; // MODE_MEASURE - don't need to do anything + case MODE_VERIFY: for(int i = 0; i < size; i++) _dbg_assert_msg_(COMMON, ((u8*)data)[i] == (*ptr)[i], "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", ((u8*)data)[i], ((u8*)data)[i], &((u8*)data)[i], (*ptr)[i], (*ptr)[i], &(*ptr)[i]); break; + default: break; // throw an error? + } + (*ptr) += size; + } + + template<class K, class T> + void Do(std::map<K, T *> &x) + { + if (mode == MODE_READ) { + for (auto it = x.begin(), end = x.end(); it != end; ++it) + { + if (it->second != NULL) + delete it->second; + } + } + T *dv = NULL; + DoMap(x, dv); + } + + template<class K, class T> + void Do(std::map<K, T> &x) + { + T dv = T(); + DoMap(x, dv); + } + + template<class K, class T> + void DoMap(std::map<K, T> &x, T &default_val) + { + unsigned int number = (unsigned int)x.size(); + Do(number); + switch (mode) { case MODE_READ: - for (x.clear(); count != 0; --count) { - std::pair<K, V> pair; - Do(pair.first); - Do(pair.second); - x.insert(pair); + x.clear(); + while (number > 0) + { + K first = K(); + Do(first); + T second = default_val; + Do(second); + x[first] = second; + --number; + } + } + break; + case MODE_WRITE: + case MODE_MEASURE: + case MODE_VERIFY: + { + typename std::map<K, T>::iterator itr = x.begin(); + while (number > 0) + { + K first = itr->first; + Do(first); + Do(itr->second); + --number; + ++itr; + } } break; + } + } + + template<class K, class T> + void Do(std::multimap<K, T *> &x) + { + if (mode == MODE_READ) + { + for (auto it = x.begin(), end = x.end(); it != end; ++it) + { + if (it->second != NULL) + delete it->second; + } + } + T *dv = NULL; + DoMultimap(x, dv); + } + + template<class K, class T> + void Do(std::multimap<K, T> &x) + { + T dv = T(); + DoMultimap(x, dv); + } + template<class K, class T> + void DoMultimap(std::multimap<K, T> &x, T &default_val) + { + unsigned int number = (unsigned int)x.size(); + Do(number); + switch (mode) { + case MODE_READ: + { + x.clear(); + while (number > 0) + { + K first = K(); + Do(first); + T second = default_val; + Do(second); + x.insert(std::make_pair(first, second)); + --number; + } + } + break; case MODE_WRITE: case MODE_MEASURE: case MODE_VERIFY: - for (auto itr = x.begin(); itr != x.end(); ++itr) { - Do(itr->first); - Do(itr->second); + typename std::multimap<K, T>::iterator itr = x.begin(); + while (number > 0) + { + Do(itr->first); + Do(itr->second); + --number; + ++itr; + } } break; } } - template <typename T> - void DoContainer(T& x) + // Store vectors. + template<class T> + void Do(std::vector<T *> &x) { - u32 size = (u32)x.size(); - Do(size); - x.resize(size); + T *dv = NULL; + DoVector(x, dv); + } - for (auto itr = x.begin(); itr != x.end(); ++itr) - Do(*itr); + template<class T> + void Do(std::vector<T> &x) + { + T dv = T(); + DoVector(x, dv); } - template <typename T> - void Do(std::vector<T>& x) + + template<class T> + void DoPOD(std::vector<T> &x) { - DoContainer(x); + T dv = T(); + DoVectorPOD(x, dv); } - template <typename T> - void Do(std::list<T>& x) + template<class T> + void Do(std::vector<T> &x, T &default_val) { - DoContainer(x); + DoVector(x, default_val); } - template <typename T> - void Do(std::deque<T>& x) + template<class T> + void DoVector(std::vector<T> &x, T &default_val) { - DoContainer(x); + u32 vec_size = (u32)x.size(); + Do(vec_size); + x.resize(vec_size, default_val); + if (vec_size > 0) + DoArray(&x[0], vec_size); } - template <typename T> - void Do(std::basic_string<T>& x) + template<class T> + void DoVectorPOD(std::vector<T> &x, T &default_val) { - DoContainer(x); + u32 vec_size = (u32)x.size(); + Do(vec_size); + x.resize(vec_size, default_val); + if (vec_size > 0) + DoArray(&x[0], vec_size); + } + + // Store deques. + template<class T> + void Do(std::deque<T *> &x) + { + T *dv = NULL; + DoDeque(x, dv); + } + + template<class T> + void Do(std::deque<T> &x) + { + T dv = T(); + DoDeque(x, dv); } - template <typename T> - void DoArray(T* x, u32 count) + template<class T> + void DoDeque(std::deque<T> &x, T &default_val) { - for (u32 i = 0; i != count; ++i) + u32 deq_size = (u32)x.size(); + Do(deq_size); + x.resize(deq_size, default_val); + u32 i; + for(i = 0; i < deq_size; i++) Do(x[i]); } - template <typename T> - void Do(T& x) + // Store STL lists. + template<class T> + void Do(std::list<T *> &x) { - // Ideally this would be std::is_trivially_copyable, but not enough support yet - static_assert(std::is_pod<T>::value, "Only sane for POD types"); - - DoVoid((void*)&x, sizeof(x)); + T *dv = NULL; + Do(x, dv); } - - template <typename T> - void DoPOD(T& x) + + template<class T> + void Do(std::list<T> &x) + { + T dv = T(); + DoList(x, dv); + } + + template<class T> + void Do(std::list<T> &x, T &default_val) + { + DoList(x, default_val); + } + + template<class T> + void DoList(std::list<T> &x, T &default_val) + { + u32 list_size = (u32)x.size(); + Do(list_size); + x.resize(list_size, default_val); + + typename std::list<T>::iterator itr, end; + for (itr = x.begin(), end = x.end(); itr != end; ++itr) + Do(*itr); + } + + + // Store STL sets. + template <class T> + void Do(std::set<T *> &x) + { + if (mode == MODE_READ) + { + for (auto it = x.begin(), end = x.end(); it != end; ++it) + { + if (*it != NULL) + delete *it; + } + } + DoSet(x); + } + + template <class T> + void Do(std::set<T> &x) + { + DoSet(x); + } + + template <class T> + void DoSet(std::set<T> &x) + { + unsigned int number = (unsigned int)x.size(); + Do(number); + + switch (mode) + { + case MODE_READ: + { + x.clear(); + while (number-- > 0) + { + T it = T(); + Do(it); + x.insert(it); + } + } + break; + case MODE_WRITE: + case MODE_MEASURE: + case MODE_VERIFY: + { + typename std::set<T>::iterator itr = x.begin(); + while (number-- > 0) + Do(*itr++); + } + break; + + default: + ERROR_LOG(COMMON, "Savestate error: invalid mode %d.", mode); + } + } + + // Store strings. + void Do(std::string &x) { - DoVoid((void*)&x, sizeof(x)); + int stringLen = (int)x.length() + 1; + Do(stringLen); + + switch (mode) { + case MODE_READ: x = (char*)*ptr; break; + case MODE_WRITE: memcpy(*ptr, x.c_str(), stringLen); break; + case MODE_MEASURE: break; + case MODE_VERIFY: _dbg_assert_msg_(COMMON, !strcmp(x.c_str(), (char*)*ptr), "Savestate verification failure: \"%s\" != \"%s\" (at %p).\n", x.c_str(), (char*)*ptr, ptr); break; + } + (*ptr) += stringLen; } - template <typename T> - void DoPointer(T*& x, T* const base) + void Do(std::wstring &x) { + int stringLen = sizeof(wchar_t)*((int)x.length() + 1); + Do(stringLen); + + switch (mode) { + case MODE_READ: x = (wchar_t*)*ptr; break; + case MODE_WRITE: memcpy(*ptr, x.c_str(), stringLen); break; + case MODE_MEASURE: break; + case MODE_VERIFY: _dbg_assert_msg_(COMMON, x == (wchar_t*)*ptr, "Savestate verification failure: \"%ls\" != \"%ls\" (at %p).\n", x.c_str(), (wchar_t*)*ptr, ptr); break; + } + (*ptr) += stringLen; + } + + template<class T> + void DoClass(T &x) { + x.DoState(*this); + } + + template<class T> + void DoClass(T *&x) { + if (mode == MODE_READ) + { + if (x != NULL) + delete x; + x = new T(); + } + x->DoState(*this); + } + + template<class T> + void DoArray(T *x, int count) { + DoHelper<T>::DoArray(this, x, count); + } + + template<class T> + void Do(T &x) { + DoHelper<T>::Do(this, x); + } + + template<class T> + void DoPOD(T &x) { + DoHelper<T>::Do(this, x); + } + + template<class T> + void DoPointer(T* &x, T*const base) { // pointers can be more than 2^31 apart, but you're using this function wrong if you need that much range s32 offset = x - base; Do(offset); @@ -150,8 +575,7 @@ public: x = base + offset; } - // Let's pretend std::list doesn't exist! - template <class T, LinkedListItem<T>* (*TNew)(), void (*TFree)(LinkedListItem<T>*), void (*TDo)(PointerWrap&, T*)> + template<class T, LinkedListItem<T>* (*TNew)(), void (*TFree)(LinkedListItem<T>*), void (*TDo)(PointerWrap&, T*)> void DoLinkedList(LinkedListItem<T>*& list_start, LinkedListItem<T>** list_end=0) { LinkedListItem<T>* list_cur = list_start; @@ -211,66 +635,48 @@ public: } } - void DoMarker(const char* prevName, u32 arbitraryNumber = 0x42) + void DoMarker(const char* prevName, u32 arbitraryNumber=0x42) { u32 cookie = arbitraryNumber; Do(cookie); - - if (mode == PointerWrap::MODE_READ && cookie != arbitraryNumber) + if(mode == PointerWrap::MODE_READ && cookie != arbitraryNumber) { - PanicAlertT("Error: After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). Aborting savestate load...", - prevName, cookie, cookie, arbitraryNumber, arbitraryNumber); - mode = PointerWrap::MODE_MEASURE; + PanicAlertT("Error: After \"%s\", found %d (0x%X) instead of save marker %d (0x%X). Aborting savestate load...", prevName, cookie, cookie, arbitraryNumber, arbitraryNumber); + SetError(ERROR_FAILURE); } } +}; -private: - __forceinline void DoByte(u8& x) - { - switch (mode) - { - case MODE_READ: - x = **ptr; - break; - - case MODE_WRITE: - **ptr = x; - break; - - case MODE_MEASURE: - break; - - case MODE_VERIFY: - _dbg_assert_msg_(COMMON, (x == **ptr), - "Savestate verification failure: %d (0x%X) (at %p) != %d (0x%X) (at %p).\n", - x, x, &x, **ptr, **ptr, *ptr); - break; - - default: - break; - } - - ++(*ptr); +inline PointerWrapSection::~PointerWrapSection() { + if (ver_ > 0) { + p_.DoMarker(title_); } +} - void DoVoid(void *data, u32 size) - { - for(u32 i = 0; i != size; ++i) - DoByte(reinterpret_cast<u8*>(data)[i]); - } -}; class CChunkFileReader { public: + enum Error { + ERROR_NONE, + ERROR_BAD_FILE, + ERROR_BROKEN_STATE, + }; + // Load file template template<class T> - static bool Load(const std::string& _rFilename, u32 _Revision, T& _class) + static Error Load(const std::string& _rFilename, int _Revision, const char *_VersionString, T& _class, std::string* _failureReason) { INFO_LOG(COMMON, "ChunkReader: Loading %s" , _rFilename.c_str()); - - if (!File::Exists(_rFilename)) - return false; + _failureReason->clear(); + _failureReason->append("LoadStateWrongVersion"); + + if (!File::Exists(_rFilename)) { + _failureReason->clear(); + _failureReason->append("LoadStateDoesntExist"); + ERROR_LOG(COMMON, "ChunkReader: File doesn't exist"); + return ERROR_BAD_FILE; + } // Check file size const u64 fileSize = File::GetSize(_rFilename); @@ -278,14 +684,14 @@ public: if (fileSize < headerSize) { ERROR_LOG(COMMON,"ChunkReader: File too small"); - return false; + return ERROR_BAD_FILE; } File::IOFile pFile(_rFilename, "rb"); if (!pFile) { ERROR_LOG(COMMON,"ChunkReader: Can't open file for reading"); - return false; + return ERROR_BAD_FILE; } // read the header @@ -293,91 +699,175 @@ public: if (!pFile.ReadArray(&header, 1)) { ERROR_LOG(COMMON,"ChunkReader: Bad header size"); - return false; + return ERROR_BAD_FILE; } - + // Check revision if (header.Revision != _Revision) { ERROR_LOG(COMMON,"ChunkReader: Wrong file revision, got %d expected %d", header.Revision, _Revision); - return false; + return ERROR_BAD_FILE; + } + + if (strcmp(header.GitVersion, _VersionString) != 0) + { + WARN_LOG(COMMON, "This savestate was generated by a different version of PPSSPP, %s. It may not load properly.", + header.GitVersion); } // get size - const u32 sz = (u32)(fileSize - headerSize); + const int sz = (int)(fileSize - headerSize); if (header.ExpectedSize != sz) { ERROR_LOG(COMMON,"ChunkReader: Bad file size, got %d expected %d", sz, header.ExpectedSize); - return false; + return ERROR_BAD_FILE; } - + // read the state - std::vector<u8> buffer(sz); - if (!pFile.ReadArray(&buffer[0], sz)) + u8* buffer = new u8[sz]; + if (!pFile.ReadBytes(buffer, sz)) { ERROR_LOG(COMMON,"ChunkReader: Error reading file"); - return false; + return ERROR_BAD_FILE; + } + + u8 *ptr = buffer; + u8 *buf = buffer; + if (header.Compress) { + u8 *uncomp_buffer = new u8[header.UncompressedSize]; + size_t uncomp_size = header.UncompressedSize; + snappy_uncompress((const char *)buffer, sz, (char *)uncomp_buffer, &uncomp_size); + if ((int)uncomp_size != header.UncompressedSize) { + ERROR_LOG(COMMON,"Size mismatch: file: %i calc: %i", (int)header.UncompressedSize, (int)uncomp_size); + } + ptr = uncomp_buffer; + buf = uncomp_buffer; + delete [] buffer; } - u8* ptr = &buffer[0]; PointerWrap p(&ptr, PointerWrap::MODE_READ); _class.DoState(p); + delete[] buf; INFO_LOG(COMMON, "ChunkReader: Done loading %s" , _rFilename.c_str()); - return true; + if (p.error != p.ERROR_FAILURE) { + return ERROR_NONE; + } else { + return ERROR_BROKEN_STATE; + } } - + // Save file template template<class T> - static bool Save(const std::string& _rFilename, u32 _Revision, T& _class) + static Error Save(const std::string& _rFilename, int _Revision, const char *_VersionString, T& _class) { INFO_LOG(COMMON, "ChunkReader: Writing %s" , _rFilename.c_str()); + File::IOFile pFile(_rFilename, "wb"); if (!pFile) { ERROR_LOG(COMMON,"ChunkReader: Error opening file for write"); - return false; + return ERROR_BAD_FILE; } + bool compress = true; + // Get data u8 *ptr = 0; PointerWrap p(&ptr, PointerWrap::MODE_MEASURE); _class.DoState(p); size_t const sz = (size_t)ptr; - std::vector<u8> buffer(sz); + + u8 * buffer = new u8[sz]; ptr = &buffer[0]; p.SetMode(PointerWrap::MODE_WRITE); _class.DoState(p); // Create header SChunkHeader header; + header.Compress = compress ? 1 : 0; header.Revision = _Revision; - header.ExpectedSize = (u32)sz; + header.ExpectedSize = (int)sz; + header.UncompressedSize = (int)sz; + strncpy(header.GitVersion, _VersionString, 32); + header.GitVersion[31] = '\0'; // Write to file - if (!pFile.WriteArray(&header, 1)) - { - ERROR_LOG(COMMON,"ChunkReader: Failed writing header"); - return false; + if (compress) { + size_t comp_len = snappy_max_compressed_length(sz); + u8 *compressed_buffer = new u8[comp_len]; + snappy_compress((const char *)buffer, sz, (char *)compressed_buffer, &comp_len); + delete [] buffer; + header.ExpectedSize = (int)comp_len; + if (!pFile.WriteArray(&header, 1)) + { + ERROR_LOG(COMMON,"ChunkReader: Failed writing header"); + return ERROR_BAD_FILE; + } + if (!pFile.WriteBytes(&compressed_buffer[0], comp_len)) { + ERROR_LOG(COMMON,"ChunkReader: Failed writing compressed data"); + return ERROR_BAD_FILE; + } else { + INFO_LOG(COMMON, "Savestate: Compressed %i bytes into %i", (int)sz, (int)comp_len); + } + delete [] compressed_buffer; + } else { + if (!pFile.WriteArray(&header, 1)) + { + ERROR_LOG(COMMON,"ChunkReader: Failed writing header"); + return ERROR_BAD_FILE; + } + if (!pFile.WriteBytes(&buffer[0], sz)) + { + ERROR_LOG(COMMON,"ChunkReader: Failed writing data"); + return ERROR_BAD_FILE; + } + delete [] buffer; } - - if (!pFile.WriteArray(&buffer[0], sz)) - { - ERROR_LOG(COMMON,"ChunkReader: Failed writing data"); - return false; + + INFO_LOG(COMMON,"ChunkReader: Done writing %s", + _rFilename.c_str()); + if (p.error != p.ERROR_FAILURE) { + return ERROR_NONE; + } else { + return ERROR_BROKEN_STATE; } + } + + template <class T> + static Error Verify(T& _class) + { + u8 *ptr = 0; - INFO_LOG(COMMON,"ChunkReader: Done writing %s", _rFilename.c_str()); - return true; + // Step 1: Measure the space required. + PointerWrap p(&ptr, PointerWrap::MODE_MEASURE); + _class.DoState(p); + size_t const sz = (size_t)ptr; + std::vector<u8> buffer(sz); + + // Step 2: Dump the state. + ptr = &buffer[0]; + p.SetMode(PointerWrap::MODE_WRITE); + _class.DoState(p); + + // Step 3: Verify the state. + ptr = &buffer[0]; + p.SetMode(PointerWrap::MODE_VERIFY); + _class.DoState(p); + + return ERROR_NONE; } private: struct SChunkHeader { - u32 Revision; - u32 ExpectedSize; + int Revision; + int Compress; + int ExpectedSize; + int UncompressedSize; + char GitVersion[32]; }; }; |