Merge remote-tracking branch 'own/prince' into prince-malik

Conflicts:
	engines/prince/debugger.cpp
	engines/prince/debugger.h
	engines/prince/detection.cpp
	engines/prince/font.cpp
	engines/prince/graphics.cpp
	engines/prince/prince.cpp
	engines/prince/prince.h
	engines/prince/script.cpp
	engines/prince/script.h

2 files changed, 283 insertions, 0 deletions

diff --git a/engines/zvision/archives/zfs_archive.cpp b/engines/zvision/archives/zfs_archive.cpp
new file mode 100644
index 0000000000..b8175b4903
--- /dev/null
+++ b/engines/zvision/archives/zfs_archive.cpp
@@ -0,0 +1,157 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 (at your option) 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "common/scummsys.h"
+
+#include "zvision/archives/zfs_archive.h"
+
+#include "common/memstream.h"
+#include "common/debug.h"
+#include "common/file.h"
+
+namespace ZVision {
+
+ZfsArchive::ZfsArchive(const Common::String &fileName) : _fileName(fileName) {
+	Common::File zfsFile;
+
+	if (!zfsFile.open(_fileName)) {
+		warning("ZFSArchive::ZFSArchive(): Could not find the archive file");
+		return;
+	}
+
+	readHeaders(&zfsFile);
+
+	debug(1, "ZfsArchive::ZfsArchive(%s): Located %d files", _fileName.c_str(), _entryHeaders.size());
+}
+
+ZfsArchive::ZfsArchive(const Common::String &fileName, Common::SeekableReadStream *stream) : _fileName(fileName) {
+	readHeaders(stream);
+
+	debug(1, "ZfsArchive::ZfsArchive(%s): Located %d files", _fileName.c_str(), _entryHeaders.size());
+}
+
+ZfsArchive::~ZfsArchive() {
+	debug(1, "ZfsArchive Destructor Called");
+	ZfsEntryHeaderMap::iterator it = _entryHeaders.begin();
+	for ( ; it != _entryHeaders.end(); ++it) {
+		delete it->_value;
+	}
+}
+
+void ZfsArchive::readHeaders(Common::SeekableReadStream *stream) {
+	// Don't do a straight struct cast since we can't guarantee endianness
+	_header.magic = stream->readUint32LE();
+	_header.unknown1 = stream->readUint32LE();
+	_header.maxNameLength = stream->readUint32LE();
+	_header.filesPerBlock = stream->readUint32LE();
+	_header.fileCount = stream->readUint32LE();
+	_header.xorKey[0] = stream->readByte();
+	_header.xorKey[1] = stream->readByte();
+	_header.xorKey[2] = stream->readByte();
+	_header.xorKey[3] = stream->readByte();
+	_header.fileSectionOffset = stream->readUint32LE();
+
+	uint32 nextOffset;
+
+	do {
+		// Read the offset to the next block
+		nextOffset = stream->readUint32LE();
+
+		// Read in each entry header
+		for (uint32 i = 0; i < _header.filesPerBlock; ++i) {
+			ZfsEntryHeader entryHeader;
+			
+			entryHeader.name = readEntryName(stream);
+			entryHeader.offset = stream->readUint32LE();
+			entryHeader.id = stream->readUint32LE();
+			entryHeader.size = stream->readUint32LE();
+			entryHeader.time = stream->readUint32LE();
+			entryHeader.unknown = stream->readUint32LE();
+
+			if (entryHeader.size != 0)
+				_entryHeaders[entryHeader.name] = new ZfsEntryHeader(entryHeader);
+		}
+
+		// Seek to the next block of headers
+		stream->seek(nextOffset);
+	} while (nextOffset != 0);
+}
+
+Common::String ZfsArchive::readEntryName(Common::SeekableReadStream *stream) const {
+	// Entry Names are at most 16 bytes and are null padded
+	char buffer[16];
+	stream->read(buffer, 16);
+
+	return Common::String(buffer);
+}
+
+bool ZfsArchive::hasFile(const Common::String &name) const {
+	return _entryHeaders.contains(name);
+}
+
+int ZfsArchive::listMembers(Common::ArchiveMemberList &list) const {
+	int matches = 0;
+
+	for (ZfsEntryHeaderMap::const_iterator it = _entryHeaders.begin(); it != _entryHeaders.end(); ++it) {
+		list.push_back(Common::ArchiveMemberList::value_type(new Common::GenericArchiveMember(it->_value->name, this)));
+		matches++;
+	}
+
+	return matches;
+}
+
+const Common::ArchiveMemberPtr ZfsArchive::getMember(const Common::String &name) const {
+	if (!_entryHeaders.contains(name))
+		return Common::ArchiveMemberPtr();
+
+	return Common::ArchiveMemberPtr(new Common::GenericArchiveMember(name, this));
+}
+
+Common::SeekableReadStream *ZfsArchive::createReadStreamForMember(const Common::String &name) const {
+	if (!_entryHeaders.contains(name)) {
+		return 0;
+	}
+
+	ZfsEntryHeader *entryHeader = _entryHeaders[name];
+
+	Common::File zfsArchive;
+	zfsArchive.open(_fileName);
+	zfsArchive.seek(entryHeader->offset);
+
+	// This *HAS* to be malloc (not new[]) because MemoryReadStream uses free() to free the memory
+	byte* buffer = (byte *)malloc(entryHeader->size);
+	zfsArchive.read(buffer, entryHeader->size);
+	// Decrypt the data in place
+	if (_header.xorKey != 0)
+		unXor(buffer, entryHeader->size, _header.xorKey);
+
+	return new Common::MemoryReadStream(buffer, entryHeader->size, DisposeAfterUse::YES);
+}
+
+void ZfsArchive::unXor(byte *buffer, uint32 length, const byte *xorKey) const {
+	for (uint32 i = 0; i < length; ++i)
+		buffer[i] ^= xorKey[i % 4];
+}
+
+} // End of namespace ZVision
+
+
diff --git a/engines/zvision/archives/zfs_archive.h b/engines/zvision/archives/zfs_archive.h
new file mode 100644
index 0000000000..d7b45e4b47
--- /dev/null
+++ b/engines/zvision/archives/zfs_archive.h
@@ -0,0 +1,126 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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 (at your option) 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef ZVISION_ZFS_ARCHIVE_H
+#define ZVISION_ZFS_ARCHIVE_H
+
+#include "common/archive.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+
+
+namespace Common {
+class String;
+}
+
+namespace ZVision {
+
+struct ZfsHeader {
+	uint32 magic;
+	uint32 unknown1;
+	uint32 maxNameLength;
+	uint32 filesPerBlock;
+	uint32 fileCount;
+	byte xorKey[4];
+	uint32 fileSectionOffset;
+};
+
+struct ZfsEntryHeader {
+	Common::String name;
+	uint32 offset;
+	uint32 id;
+	uint32 size;
+	uint32 time;
+	uint32 unknown;
+};
+
+typedef Common::HashMap<Common::String, ZfsEntryHeader*, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> ZfsEntryHeaderMap;
+
+class ZfsArchive : public Common::Archive {
+public:
+	ZfsArchive(const Common::String &fileName);
+	ZfsArchive(const Common::String &fileName, Common::SeekableReadStream *stream);
+	~ZfsArchive();
+
+	/**
+	 * Check if a member with the given name is present in the Archive.
+	 * Patterns are not allowed, as this is meant to be a quick File::exists()
+	 * replacement.
+	 */
+	bool hasFile(const Common::String &fileName) const;
+
+	/**
+	 * Add all members of the Archive to list.
+	 * Must only append to list, and not remove elements from it.
+	 *
+	 * @return    The number of names added to list
+	 */
+	int listMembers(Common::ArchiveMemberList &list) const;
+
+	/**
+	 * Returns a ArchiveMember representation of the given file.
+	 */
+	const Common::ArchiveMemberPtr getMember(const Common::String &name) const;
+
+	/**
+	 * Create a stream bound to a member with the specified name in the
+	 * archive. If no member with this name exists, 0 is returned.
+	 *
+	 * @return    The newly created input stream
+	 */
+	Common::SeekableReadStream *createReadStreamForMember(const Common::String &name) const;
+
+private:
+	const Common::String _fileName;
+	ZfsHeader _header;
+	ZfsEntryHeaderMap _entryHeaders;
+
+	/**
+	 * Parses the zfs file into file entry headers that can be used later
+	 * to get the entry data.
+	 *
+	 * @param stream    The contents of the zfs file
+	 */
+	void readHeaders(Common::SeekableReadStream *stream);
+
+	/**
+	 * Entry names are contained within a 16 byte block. This reads the block
+	 * and converts it the name to a Common::String
+	 *
+	 * @param stream    The zfs file stream
+	 * @return          The entry file name
+	 */
+	Common::String readEntryName(Common::SeekableReadStream *stream) const;
+
+	/**
+	 * ZFS file entries can be encrypted using XOR encoding. This method
+	 * decodes the buffer in place using the supplied xorKey.
+	 *
+	 * @param buffer    The data to decode
+	 * @param length    Length of buffer
+	 */
+	void unXor(byte *buffer, uint32 length, const byte *xorKey) const;
+};
+
+} // End of namespace ZVision
+
+#endif