Added support for compressed x files (all files from dx sdk, except car2.x, work, no further tests yet).

Added a working makefile for mingw, provides more configs now. Not perfect yet.
Added decompression part of zlib (inflate).
Moved IrrXML to ./contrib dir.
Moved some IRR/IRRmesh shared code.
FIXME: makefile for gnu/linux is untested yet.
Code cleanup.
Unified #ifndef ASSIMP_BUILD_nnn_IMPORTER directives.
OBJ loader supports map_bump, map_ka, map_ks, map_ns now.
Endianess conversion in the ply loader is correct now.
Changed IRR/IRRMESH coordinate system conversion. Not absolutely right now, but better than before.


git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@305 67173fc5-114c-0410-ac8e-9d2fd5bffc1f

code/3DSConverter.cpp

@@ -41,8 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the 3ds importer class */
 
-
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers
 #include "3DSLoader.h"
@@ -125,16 +125,13 @@ void Discreet3DSImporter::ReplaceDefaultMaterial()
 
 		DefaultLogger::get()->info("3DS: Generating default material");
 	}
-	return;
 }
 
 // ------------------------------------------------------------------------------------------------
-// Check whether all indices are valid. Otherwise we'd crash before the validation step was reached
+// Check whether all indices are valid. Otherwise we'd crash before the validation step is reached
 void Discreet3DSImporter::CheckIndices(D3DS::Mesh& sMesh)
 {
-	for (std::vector< D3DS::Face >::iterator
-		 i =  sMesh.mFaces.begin();
-		 i != sMesh.mFaces.end();++i)
+	for (std::vector< D3DS::Face >::iterator i =  sMesh.mFaces.begin(); i != sMesh.mFaces.end();++i)
 	{
 		// check whether all indices are in range
 		for (unsigned int a = 0; a < 3;++a)
@@ -151,13 +148,15 @@ void Discreet3DSImporter::CheckIndices(D3DS::Mesh& sMesh)
 			}
 		}
 	}
-	return;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Generate out unique verbose format representation
 void Discreet3DSImporter::MakeUnique(D3DS::Mesh& sMesh)
 {
+	// TODO: really necessary? I don't think. Just a waste of memory and time
+	// to do it now in a separate buffer. 
+
 	// Allocate output storage
 	std::vector<aiVector3D> vNew  (sMesh.mFaces.size() * 3);
 	std::vector<aiVector3D> vNew2;
@@ -180,10 +179,10 @@ void Discreet3DSImporter::MakeUnique(D3DS::Mesh& sMesh)
 	}
 	sMesh.mPositions = vNew;
 	sMesh.mTexCoords = vNew2;
-	return;
 }
 
 // ------------------------------------------------------------------------------------------------
+// Convert a 3DS texture to texture keys in an aiMaterial
 void CopyTexture(MaterialHelper& mat, D3DS::Texture& texture, aiTextureType type)
 {
 	// Setup the texture name
@@ -200,6 +199,7 @@ void CopyTexture(MaterialHelper& mat, D3DS::Texture& texture, aiTextureType type
 	mat.AddProperty<int>((int*)&texture.mMapMode,1,AI_MATKEY_MAPPINGMODE_V(type,0));
 
 	// Mirroring - double the scaling values 
+	// FIXME: this is not really correct ...
 	if (texture.mMapMode == aiTextureMapMode_Mirror)
 	{
 		texture.mScaleU *= 2.f;
@@ -337,7 +337,6 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material& oldMat,
 		tex.Set( oldMat.mName);
 		mat.AddProperty( &tex, AI_MATKEY_NAME);
 	}
-	return;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -642,7 +641,6 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
 		pcOut->mChildren[i]->mParent = pcOut;
 		AddNodeToGraph(pcSOut,pcOut->mChildren[i],pcIn->mChildren[i],abs);
 	}
-	return;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -809,6 +807,6 @@ void Discreet3DSImporter::ConvertScene(aiScene* pcOut)
 		pcOut->mCameras = new aiCamera*[pcOut->mNumCameras];
 		::memcpy(pcOut->mCameras,&mScene->mCameras[0],sizeof(void*)*pcOut->mNumCameras);
 	}
-
-	return;
 }
+
+#endif // !! ASSIMP_BUILD_NO_3DS_IMPORTER

code/3DSLoader.cpp

@@ -42,10 +42,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the 3ds importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers
 #include "3DSLoader.h"
-#include "TextureTransform.h"
 
 using namespace Assimp;
 		
@@ -53,36 +53,32 @@ using namespace Assimp;
 // Begins a new parsing block
 // - Reads the current chunk and validates it
 // - computes its length
-
-#define ASSIMP_3DS_BEGIN_CHUNK() \
-	Discreet3DS::Chunk chunk; \
-	ReadChunk(&chunk); \
-	int chunkSize = chunk.Size-sizeof(Discreet3DS::Chunk); \
-	int oldReadLimit = stream->GetReadLimit(); \
+#define ASSIMP_3DS_BEGIN_CHUNK()                                     \
+	Discreet3DS::Chunk chunk;                                        \
+	ReadChunk(&chunk);                                               \
+	int chunkSize = chunk.Size-sizeof(Discreet3DS::Chunk);	         \
+	const int oldReadLimit = stream->GetReadLimit();                 \
 	stream->SetReadLimit(stream->GetCurrentPos() + chunkSize);
 	
 
 // ------------------------------------------------------------------------------------------------
 // End a parsing block
-// Must follow at the end of each parsing block
-
-#define ASSIMP_3DS_END_CHUNK() \
-	stream->SkipToReadLimit(); \
-	stream->SetReadLimit(oldReadLimit); \
-	if (stream->GetRemainingSizeToLimit() == 0)return;
-
+// Must follow at the end of each parsing block, reset chunk end marker to previous value
+#define ASSIMP_3DS_END_CHUNK()                  \
+	stream->SkipToReadLimit();                  \
+	stream->SetReadLimit(oldReadLimit);         \
+	if (stream->GetRemainingSizeToLimit() == 0) \
+		return;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 Discreet3DSImporter::Discreet3DSImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 Discreet3DSImporter::~Discreet3DSImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -551,6 +547,7 @@ void Discreet3DSImporter::InverseNodeSearch(D3DS::Node* pcNode,D3DS::Node* pcCur
 }
 
 // ------------------------------------------------------------------------------------------------
+// Find a node with a specific name in the import hierarchy
 D3DS::Node* FindNode(D3DS::Node* root, const std::string& name)
 {
 	if (root->mName == name)return root;
@@ -572,6 +569,7 @@ bool KeyUniqueCompare(const T& first, const T& second)
 }
 
 // ------------------------------------------------------------------------------------------------
+// Skip some additional import data.
 void Discreet3DSImporter::SkipTCBInfo()
 {
 	unsigned int flags = stream->GetI2();
@@ -600,6 +598,7 @@ void Discreet3DSImporter::SkipTCBInfo()
 }
 
 // ------------------------------------------------------------------------------------------------
+// Read hierarchy and keyframe info
 void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 {
 	ASSIMP_3DS_BEGIN_CHUNK();
@@ -897,7 +896,9 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 	// recursively continue processing this hierarchy level
 	return ParseHierarchyChunk(parent);
 }
+
 // ------------------------------------------------------------------------------------------------
+// Read a face chunk - it contains smoothing groups and material assignments
 void Discreet3DSImporter::ParseFaceChunk()
 {
 	ASSIMP_3DS_BEGIN_CHUNK();
@@ -972,7 +973,9 @@ void Discreet3DSImporter::ParseFaceChunk()
 	// recursively continue processing this hierarchy level
 	return ParseFaceChunk();
 }
+
 // ------------------------------------------------------------------------------------------------
+// Read a mesh chunk. Here's the actual mesh data
 void Discreet3DSImporter::ParseMeshChunk()
 {
 	ASSIMP_3DS_BEGIN_CHUNK();
@@ -1095,6 +1098,7 @@ void Discreet3DSImporter::ParseMeshChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
+// Read a 3DS material chunk
 void Discreet3DSImporter::ParseMaterialChunk()
 {
 	ASSIMP_3DS_BEGIN_CHUNK();
@@ -1432,3 +1436,5 @@ void Discreet3DSImporter::ParseColorChunk(aiColor3D* out,
 		return ParseColorChunk(out,acceptPercent);
 	};
 }
+
+#endif // !! ASSIMP_BUILD_NO_3DS_IMPORTER

code/ASELoader.cpp

@@ -41,8 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the ASE importer class */
 
-
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_ASE_IMPORTER
 
 // internal headers
 #include "ASELoader.h"
@@ -60,13 +60,13 @@ using namespace Assimp::ASE;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 ASEImporter::ASEImporter()
-{
-}
+{}
+
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 ASEImporter::~ASEImporter()
-{
-}
+{}
+
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
 bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
@@ -93,7 +93,7 @@ bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
 void ASEImporter::SetupProperties(const Importer* pImp)
 {
 	configRecomputeNormals = (pImp->GetPropertyInteger(
-		AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS,0) ? true : false);
+		AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS,1) ? true : false);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -1423,3 +1423,5 @@ bool ASEImporter::GenerateNormals(ASE::Mesh& mesh)
 	ComputeNormalsWithSmoothingsGroups<ASE::Face>(mesh);
 	return false;
 }
+
+#endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER

code/B3DImporter.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the b3d importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
 
 // internal headers
 #include "B3DImporter.h"
@@ -50,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;
 using namespace std;
 
+// ------------------------------------------------------------------------------------------------
 bool B3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const{
 
 	int pos=pFile.find_last_of( '.' );
@@ -61,10 +63,12 @@ bool B3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
 	return (ext[0]=='b' || ext[0]=='B') && (ext[1]=='3') && (ext[2]=='d' || ext[2]=='D');
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::GetExtensionList( std::string& append ){
 	append.append("*.b3d");
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler){
 
 	boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
@@ -115,11 +119,13 @@ void B3DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
 	pScene->mRootNode=node;
 }
 
+// ------------------------------------------------------------------------------------------------
 int B3DImporter::ReadByte(){
 	if( _pos<_buf.size() ) return _buf[_pos++];
 	throw new ImportErrorException( "B3D EOF Error" );
 }
 
+// ------------------------------------------------------------------------------------------------
 int B3DImporter::ReadInt(){
 	if( _pos+4<=_buf.size() ){
 		int n=*(int*)&_buf[_pos];
@@ -129,6 +135,7 @@ int B3DImporter::ReadInt(){
 	throw new ImportErrorException( "B3D EOF Error" );
 }
 
+// ------------------------------------------------------------------------------------------------
 float B3DImporter::ReadFloat(){
 	if( _pos+4<=_buf.size() ){
 		float n=*(float*)&_buf[_pos];
@@ -138,6 +145,7 @@ float B3DImporter::ReadFloat(){
 	throw new ImportErrorException( "B3D EOF Error" );
 }
 
+// ------------------------------------------------------------------------------------------------
 B3DImporter::Vec2 B3DImporter::ReadVec2(){
 	Vec2 t;
 	t.x=ReadFloat();
@@ -145,6 +153,7 @@ B3DImporter::Vec2 B3DImporter::ReadVec2(){
 	return t;
 }
 
+// ------------------------------------------------------------------------------------------------
 B3DImporter::Vec3 B3DImporter::ReadVec3(){
 	Vec3 t;
 	t.x=ReadFloat();
@@ -153,6 +162,7 @@ B3DImporter::Vec3 B3DImporter::ReadVec3(){
 	return t;
 }
 
+// ------------------------------------------------------------------------------------------------
 B3DImporter::Vec4 B3DImporter::ReadVec4(){
 	Vec4 t;
 	t.x=ReadFloat();
@@ -162,6 +172,7 @@ B3DImporter::Vec4 B3DImporter::ReadVec4(){
 	return t;
 }
 
+// ------------------------------------------------------------------------------------------------
 string B3DImporter::ReadString(){
 	string str;
 	while( _pos<_buf.size() ){
@@ -172,6 +183,7 @@ string B3DImporter::ReadString(){
 	throw new ImportErrorException( "B3D EOF Error" );
 }
 
+// ------------------------------------------------------------------------------------------------
 string B3DImporter::ReadChunk(){
 	string tag;
 	for( int i=0;i<4;++i ){
@@ -183,15 +195,18 @@ string B3DImporter::ReadChunk(){
 	return tag;
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ExitChunk(){
 	_pos=_stack.back();
 	_stack.pop_back();
 }
 
+// ------------------------------------------------------------------------------------------------
 unsigned B3DImporter::ChunkSize(){
 	return _stack.back()-_pos;
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadTEXS(){
 	while( ChunkSize() ){
 		string name=ReadString();
@@ -207,6 +222,7 @@ void B3DImporter::ReadTEXS(){
 	}
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadBRUS(){
 	int n_texs=ReadInt();
 	while( ChunkSize() ){
@@ -257,6 +273,7 @@ void B3DImporter::ReadBRUS(){
 	}
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadVRTS(){
 	int vertFlags=ReadInt();
 	int tc_sets=ReadInt();
@@ -288,6 +305,7 @@ void B3DImporter::ReadVRTS(){
 	}
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadTRIS(){
 	int matid=ReadInt();
 
@@ -323,6 +341,7 @@ void B3DImporter::ReadTRIS(){
 	}
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadMESH(){
 	int matid=ReadInt();
 
@@ -341,6 +360,7 @@ void B3DImporter::ReadMESH(){
 	_vertices.clear();
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadNODE(){
 
 	string name=ReadString();
@@ -357,6 +377,7 @@ void B3DImporter::ReadNODE(){
 	}
 }
 
+// ------------------------------------------------------------------------------------------------
 void B3DImporter::ReadBB3D(){
 	string t=ReadChunk();
 	if( t=="BB3D" ){
@@ -375,3 +396,5 @@ void B3DImporter::ReadBB3D(){
 	}
 	ExitChunk();
 }
+
+#endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER

code/BVHLoader.cpp

@@ -41,7 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AssimpPCH.h"
-#include "../include/aiAnim.h"
+#ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
+
 #include "BVHLoader.h"
 #include "fast_atof.h"
 #include "SkeletonMeshBuilder.h"
@@ -528,3 +529,5 @@ void BVHLoader::CreateAnimation( aiScene* pScene)
 		}
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_BVH_IMPORTER

code/ColladaLoader.cpp

@@ -42,6 +42,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the Collada loader */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_DAE_IMPORTER
+
 #include "../include/aiAnim.h"
 #include "ColladaLoader.h"
 #include "ColladaParser.h"
@@ -405,3 +407,5 @@ void ColladaLoader::ConvertPath (aiString& ss)
 		ss.data[ss.length] = '\0';
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER

code/ColladaParser.cpp

@@ -41,6 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_DAE_IMPORTER
+
 #include "ColladaParser.h"
 #include "fast_atof.h"
 #include "ParsingUtils.h"
@@ -1532,3 +1534,5 @@ Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& pSemant
 	DefaultLogger::get()->warn( boost::str( boost::format( "Unknown vertex input type \"%s\". Ignoring.") % pSemantic));
 	return IT_Invalid;
 }
+
+#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER

code/ColladaParser.h

@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLLADAPARSER_H_INC
 #define AI_COLLADAPARSER_H_INC
 
-#include "./irrXML/irrXMLWrapper.h"
+#include "irrXMLWrapper.h"
 #include "ColladaHelper.h"
 
 namespace Assimp

code/DXFLoader.cpp

@@ -42,20 +42,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the DXF importer class */
 
 #include "AssimpPCH.h"
-
+#ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
 
 #include "DXFLoader.h"
 #include "ParsingUtils.h"
 #include "fast_atof.h"
 
-
 using namespace Assimp;
 
 // AutoCAD Binary DXF<CR><LF><SUB><NULL> 
 #define AI_DXF_BINARY_IDENT ("AutoCAD Binary DXF\r\n\x1a\0")
 #define AI_DXF_BINARY_IDENT_LEN (24)
 
-
 // color indices for DXF - 16 are supported
 static aiColor4D g_aclrDxfIndexColors[] =
 {
@@ -113,6 +111,7 @@ bool DXFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
 }
 
 // ------------------------------------------------------------------------------------------------
+// Get a copy of the next data line, skip strange data
 bool DXFImporter::GetNextLine()
 {
 	if(!SkipLine(&buffer))
@@ -135,6 +134,7 @@ bool DXFImporter::GetNextLine()
 }
 
 // ------------------------------------------------------------------------------------------------
+// Get the next token in the file
 bool DXFImporter::GetNextToken()
 {
 	if (bRepeat)
@@ -626,4 +626,5 @@ bool DXFImporter::Parse3DFace()
 	return ret;
 }
 
+#endif // !! ASSIMP_BUILD_NO_DXF_IMPORTER
 

code/HMPLoader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the MDL importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_HMP_IMPORTER
 
 // internal headers
 #include "MaterialSystem.h"
@@ -98,8 +99,8 @@ void HMPImporter::InternReadFile( const std::string& pFile,
 		throw new ImportErrorException( "HMP File is too small.");
 
 	// Allocate storage and copy the contents of the file to a memory buffer
-	this->pScene = pScene;
-	this->pIOHandler = pIOHandler;
+	pScene = pScene;
+	pIOHandler = pIOHandler;
 
 	std::vector<uint8_t> buffer(fileSize+1);
 	mBuffer = &buffer[0];
@@ -155,9 +156,9 @@ void HMPImporter::InternReadFile( const std::string& pFile,
 // ------------------------------------------------------------------------------------------------ 
 void HMPImporter::ValidateHeader_HMP457( )
 {
-	const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)this->mBuffer;
+	const HMP::Header_HMP5* const pcHeader = (const HMP::Header_HMP5*)mBuffer;
 
-	if (120 > this->iFileSize)
+	if (120 > iFileSize)
 	{
 		throw new ImportErrorException("HMP file is too small (header size is "
 			"120 bytes, this file is smaller)");
@@ -238,6 +239,7 @@ void HMPImporter::InternReadFile_HMP5( )
 	pScene->mRootNode->mMeshes = new unsigned int[1];
 	pScene->mRootNode->mMeshes[0] = 0;
 }
+
 // ------------------------------------------------------------------------------------------------ 
 void HMPImporter::InternReadFile_HMP7( )
 {
@@ -460,7 +462,9 @@ void HMPImporter::ReadFirstSkin(unsigned int iNumSkins, const unsigned char* szC
 
 	*szCursorOut = szCursor;
 }
+
 // ------------------------------------------------------------------------------------------------ 
+// Generate proepr texture coords
 void HMPImporter::GenerateTextureCoords(
 	const unsigned int width, const unsigned int height)
 {
@@ -480,3 +484,5 @@ void HMPImporter::GenerateTextureCoords(
 		}
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_HMP_IMPORTER

code/IRRLoader.cpp

@@ -60,10 +60,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 
 using namespace Assimp;
+using namespace boost::math;
 
-// Transformation matrix to convert from Assimp to IRR space
-static aiMatrix4x4 AI_TO_IRR_MATRIX = aiMatrix4x4 ( 1.0f, 0.0f, 0.0f, 
-	0.f, 0.0f, 0.0f, -1.0f, 0.f, 0.0f, 1.0f, 0.0f, 0.f, 0.f, 0.f, 0.f, 1.f);
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
@@ -1645,8 +1643,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
 
 
 	// transformation matrix to convert from IRRMESH to ASSIMP coordinates
-	pScene->mRootNode->mTransformation *= aiMatrix4x4(1.0f, 0.0f, 0.0f, 0.f, 0.0f, 0.0f, -1.0f,
-		0.f, 0.0f, 1.0f, 0.0f, 0.f, 0.f, 0.f, 0.f, 1.f);
+	pScene->mRootNode->mTransformation *= AI_TO_IRR_MATRIX;
 
 
 	/* Finished ... everything destructs automatically and all 

code/IRRLoader.h

@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IRRLOADER_H_INCLUDED
 #define AI_IRRLOADER_H_INCLUDED
 
-#include "IRRMeshLoader.h"
+#include "IRRShared.h"
 #include "SceneCombiner.h"
 
 namespace Assimp	{

code/IRRMeshLoader.cpp

@@ -43,433 +43,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "AssimpPCH.h"
 
-
 #include "IRRMeshLoader.h"
 #include "ParsingUtils.h"
 #include "fast_atof.h"
 
 using namespace Assimp;
 
-/**** AT FIRST: IrrlightBase, base class for IrrMesh and Irr *******/
-
-// ------------------------------------------------------------------------------------------------
-// read a property in hexadecimal format (i.e. ffffffff)
-void IrrlichtBase::ReadHexProperty    (HexProperty&    out)
-{
-	for (int i = 0; i < reader->getAttributeCount();++i)
-	{
-		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-		{
-			out.name = std::string( reader->getAttributeValue(i) );
-		}
-		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-		{
-			// parse the hexadecimal value
-			out.value = strtol16(reader->getAttributeValue(i));
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a decimal property
-void IrrlichtBase::ReadIntProperty    (IntProperty&    out)
-{
-	for (int i = 0; i < reader->getAttributeCount();++i)
-	{
-		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-		{
-			out.name = std::string( reader->getAttributeValue(i) );
-		}
-		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-		{
-			// parse the ecimal value
-			out.value = strtol10s(reader->getAttributeValue(i));
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a string property
-void IrrlichtBase::ReadStringProperty (StringProperty& out)
-{
-	for (int i = 0; i < reader->getAttributeCount();++i)
-	{
-		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-		{
-			out.name = std::string( reader->getAttributeValue(i) );
-		}
-		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-		{
-			// simple copy the string
-			out.value = std::string (reader->getAttributeValue(i));
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a boolean property
-void IrrlichtBase::ReadBoolProperty   (BoolProperty&   out)
-{
-	for (int i = 0; i < reader->getAttributeCount();++i)
-	{
-		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-		{
-			out.name = std::string( reader->getAttributeValue(i) );
-		}
-		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-		{
-			// true or false, case insensitive
-			out.value = (ASSIMP_stricmp( reader->getAttributeValue(i), 
-				"true") ? false : true);
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a float property
-void IrrlichtBase::ReadFloatProperty  (FloatProperty&  out)
-{
-	for (int i = 0; i < reader->getAttributeCount();++i)
-	{
-		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-		{
-			out.name = std::string( reader->getAttributeValue(i) );
-		}
-		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-		{
-			// just parse the float
-			out.value = fast_atof( reader->getAttributeValue(i) );
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-// read a vector property
-void IrrlichtBase::ReadVectorProperty  (VectorProperty&  out)
-{
-	for (int i = 0; i < reader->getAttributeCount();++i)
-	{
-		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
-		{
-			out.name = std::string( reader->getAttributeValue(i) );
-		}
-		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
-		{
-			// three floats, separated with commas
-			const char* ptr = reader->getAttributeValue(i);
-
-			SkipSpaces(&ptr);
-			ptr = fast_atof_move( ptr,(float&)out.value.x );
-			SkipSpaces(&ptr);
-			if (',' != *ptr)
-			{
-				DefaultLogger::get()->error("IRR(MESH): Expected comma in vector definition");
-			}
-			else SkipSpaces(ptr+1,&ptr);
-			ptr = fast_atof_move( ptr,(float&)out.value.y );
-			SkipSpaces(&ptr);
-			if (',' != *ptr)
-			{
-				DefaultLogger::get()->error("IRR(MESH): Expected comma in vector definition");
-			}
-			else SkipSpaces(ptr+1,&ptr);
-			ptr = fast_atof_move( ptr,(float&)out.value.z );
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-void ColorFromARGBPacked(uint32_t in, aiColor4D& clr)
-{
-	clr.a = ((in >> 24) & 0xff) / 255.f;
-	clr.r = ((in >> 16) & 0xff) / 255.f;
-	clr.g = ((in >>  8) & 0xff) / 255.f;
-	clr.b = ((in      ) & 0xff) / 255.f;
-}
-
-// ------------------------------------------------------------------------------------------------
-int ConvertMappingMode(const std::string& mode)
-{
-	if (mode == "texture_clamp_repeat")
-	{
-		return aiTextureMapMode_Wrap;
-	}
-	else if (mode == "texture_clamp_mirror")
-		return aiTextureMapMode_Mirror;
-
-	return aiTextureMapMode_Clamp;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Parse a material from the XML file
-aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags)
-{
-	MaterialHelper* mat = new MaterialHelper();
-	aiColor4D clr;
-	aiString s;
-
-	matFlags = 0; // zero output flags
-	int cnt  = 0; // number of used texture channels
-
-	// Continue reading from the file
-	while (reader->read())
-	{
-		switch (reader->getNodeType())
-		{
-		case EXN_ELEMENT:
-
-			// Hex properties
-			if (!ASSIMP_stricmp(reader->getNodeName(),"color"))
-			{
-				HexProperty prop;
-				ReadHexProperty(prop);
-				if (prop.name == "Diffuse")
-				{
-					ColorFromARGBPacked(prop.value,clr);
-					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
-				}
-				else if (prop.name == "Ambient")
-				{
-					ColorFromARGBPacked(prop.value,clr);
-					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_AMBIENT);
-				}
-				else if (prop.name == "Specular")
-				{
-					ColorFromARGBPacked(prop.value,clr);
-					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_SPECULAR);
-				}
-
-				// NOTE: The 'emissive' property causes problems. It is
-				// often != 0, even if there is obviously no light
-				// emitted by the described surface. In fact I think
-				// IRRLICHT ignores this property, too.
-#if 0
-				else if (prop.name == "Emissive")
-				{
-					ColorFromARGBPacked(prop.value,clr);
-					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
-				}
-#endif
-			}
-			// Float properties
-			else if (!ASSIMP_stricmp(reader->getNodeName(),"float"))
-			{
-				FloatProperty prop;
-				ReadFloatProperty(prop);
-				if (prop.name == "Shininess")
-				{
-					mat->AddProperty(&prop.value,1,AI_MATKEY_SHININESS);
-				}
-			}
-			// Bool properties
-			else if (!ASSIMP_stricmp(reader->getNodeName(),"bool"))
-			{
-				BoolProperty prop;
-				ReadBoolProperty(prop);
-				if (prop.name == "Wireframe")
-				{
-					int val = (prop.value ? true : false);
-					mat->AddProperty(&val,1,AI_MATKEY_ENABLE_WIREFRAME);
-				}
-				else if (prop.name == "GouraudShading")
-				{
-					int val = (prop.value ? aiShadingMode_Gouraud 
-						: aiShadingMode_NoShading);
-					mat->AddProperty(&val,1,AI_MATKEY_SHADING_MODEL);
-				}
-			}
-			// String properties - textures and texture related properties
-			else if (!ASSIMP_stricmp(reader->getNodeName(),"texture") ||
-				     !ASSIMP_stricmp(reader->getNodeName(),"enum"))
-			{
-				StringProperty prop;
-				ReadStringProperty(prop);
-				if (prop.value.length())
-				{
-					// material type (shader)
-					if (prop.name == "Type")
-					{
-						if (prop.value == "trans_vertex_alpha")
-						{
-							matFlags = AI_IRRMESH_MAT_trans_vertex_alpha;
-						}
-						else if (prop.value == "lightmap")
-						{
-							matFlags = AI_IRRMESH_MAT_lightmap;
-						}
-						else if (prop.value == "solid_2layer")
-						{
-							matFlags = AI_IRRMESH_MAT_solid_2layer;
-						}
-						else if (prop.value == "lightmap_m2")
-						{
-							matFlags = AI_IRRMESH_MAT_lightmap_m2;
-						}
-						else if (prop.value == "lightmap_m4")
-						{
-							matFlags = AI_IRRMESH_MAT_lightmap_m4;
-						}
-						else if (prop.value == "lightmap_light")
-						{
-							matFlags = AI_IRRMESH_MAT_lightmap_light;
-						}
-						else if (prop.value == "lightmap_light_m2")
-						{
-							matFlags = AI_IRRMESH_MAT_lightmap_light_m2;
-						}
-						else if (prop.value == "lightmap_light_m4")
-						{
-							matFlags = AI_IRRMESH_MAT_lightmap_light_m4;
-						}
-						else if (prop.value == "lightmap_add")
-						{
-							matFlags = AI_IRRMESH_MAT_lightmap_add;
-						}
-						// Normal and parallax maps are treated equally
-						else if (prop.value == "normalmap_solid" ||
-							prop.value == "parallaxmap_solid")
-						{
-							matFlags = AI_IRRMESH_MAT_normalmap_solid;
-						}
-						else if (prop.value == "normalmap_trans_vertex_alpha" ||
-							prop.value == "parallaxmap_trans_vertex_alpha")
-						{
-							matFlags = AI_IRRMESH_MAT_normalmap_tva;
-						}
-						else if (prop.value == "normalmap_trans_add" ||
-							prop.value == "parallaxmap_trans_add")
-						{
-							matFlags = AI_IRRMESH_MAT_normalmap_ta;
-						}
-					}
-
-					// Up to 4 texture channels are supported
-					else if (prop.name == "Texture1")
-					{
-						// Always accept the primary texture channel
-						++cnt;
-						s.Set(prop.value);
-						mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
-					}
-					else if (prop.name == "Texture2")
-					{
-						// 2-layer material lightmapped?
-						if (matFlags & (AI_IRRMESH_MAT_solid_2layer | AI_IRRMESH_MAT_lightmap))
-						{
-							++cnt;
-							s.Set(prop.value);
-							mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(1));
-
-							// set the corresponding material flag
-							matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
-						}
-						// alternatively: normal or parallax mapping
-						else if (matFlags & AI_IRRMESH_MAT_normalmap_solid)
-						{
-							++cnt;
-							s.Set(prop.value);
-							mat->AddProperty(&s,AI_MATKEY_TEXTURE_NORMALS(1));
-
-							// set the corresponding material flag
-							matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
-						}
-					}
-					else if (prop.name == "Texture3")
-					{
-						// We don't process the third texture channel as Irrlicht
-						// does not seem to use it.
-#if 0
-						++cnt;
-						s.Set(prop.value);
-						mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(2));
-#endif
-					}
-					else if (prop.name == "Texture4" )
-					{
-						// We don't process the fourth texture channel as Irrlicht
-						// does not seem to use it.
-#if 0
-						++cnt;
-						s.Set(prop.value);
-						mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(3));
-#endif
-					}
-
-					// Texture mapping options
-					if (prop.name == "TextureWrap1" && cnt >= 1)
-					{
-						int map = ConvertMappingMode(prop.value);
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
-					}
-					else if (prop.name == "TextureWrap2" && cnt >= 2)
-					{
-						int map = ConvertMappingMode(prop.value);
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1));
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1));	
-					}
-					else if (prop.name == "TextureWrap3" && cnt >= 3)
-					{
-						int map = ConvertMappingMode(prop.value);
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(2));
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(2));
-					}
-					else if (prop.name == "TextureWrap4" && cnt >= 4)
-					{
-						int map = ConvertMappingMode(prop.value);
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(3));
-						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(3));
-					}
-				}
-			}
-			break;
-			case EXN_ELEMENT_END:
-
-				/* Assume there are no further nested nodes in <material> elements
-				 */
-				if (/* IRRMESH */ !ASSIMP_stricmp(reader->getNodeName(),"material") ||
-					/* IRR     */ !ASSIMP_stricmp(reader->getNodeName(),"attributes"))
-				{
-					// Now process lightmapping flags
-					// We should have at least one texture, however
-					// if there are multiple textures we assign the
-					// lightmap settings to the last texture.
-					if (cnt && matFlags & AI_IRRMESH_MAT_lightmap)
-					{
-						float f = 1.f;
-
-						// Additive lightmap?
-						int op = (matFlags & AI_IRRMESH_MAT_lightmap_add
-							? aiTextureOp_Add : aiTextureOp_Multiply);
-
-						// Handle Irrlicht's lightmapping scaling factor
-						if (matFlags & AI_IRRMESH_MAT_lightmap_m2 ||
-							matFlags & AI_IRRMESH_MAT_lightmap_light_m2)
-						{
-							f = 2.f;
-						}
-						else if (matFlags & AI_IRRMESH_MAT_lightmap_m4 ||
-							matFlags & AI_IRRMESH_MAT_lightmap_light_m4)
-						{
-							f = 4.f;
-						}
-						mat->AddProperty( &f, 1, AI_MATKEY_TEXBLEND_DIFFUSE(cnt-1));
-						mat->AddProperty( &op,1, AI_MATKEY_TEXOP_DIFFUSE(cnt-1));
-					}
-
-					return mat;
-				}
-			default:
-
-				// GCC complains here ...
-				break;
-		}
-	}
-	DefaultLogger::get()->error("IRRMESH: Unexpected end of file. Material is not complete");
-	return mat;
-}
-
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 IRRMeshImporter::IRRMeshImporter()
@@ -959,9 +538,9 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
 		pScene->mRootNode->mMeshes[i] = i;
 
 	// transformation matrix to convert from IRRMESH to ASSIMP coordinates
-	pScene->mRootNode->mTransformation *= aiMatrix4x4(
-		1.0f, 0.0f, 0.0f, 0.f, 0.0f, 0.0f, -1.0f, 0.f, 0.0f, 1.0f, 0.0f, 0.f, 0.f, 0.f, 0.f, 1.f);
+	pScene->mRootNode->mTransformation *= AI_TO_IRR_MATRIX;
 
+	// clean up and return
 	delete reader;
 	AI_DEBUG_INVALIDATE_PTR(reader);
 }

code/IRRMeshLoader.h

@@ -43,89 +43,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IRRMESHLOADER_H_INCLUDED
 #define AI_IRRMESHLOADER_H_INCLUDED
 
-#include "./irrXML/irrXMLWrapper.h"
 #include "BaseImporter.h"
+#include "IRRShared.h"
 
 namespace Assimp	{
 
-// Default: 0 = solid, one texture
-#define AI_IRRMESH_MAT_solid_2layer			0x10000
-
-// Transparency flags
-#define AI_IRRMESH_MAT_trans_vertex_alpha	0x1
-#define AI_IRRMESH_MAT_trans_add			0x2
-
-// Lightmapping flags
-#define AI_IRRMESH_MAT_lightmap				0x2 
-#define AI_IRRMESH_MAT_lightmap_m2			(AI_IRRMESH_MAT_lightmap|0x4)
-#define AI_IRRMESH_MAT_lightmap_m4			(AI_IRRMESH_MAT_lightmap|0x8)
-#define AI_IRRMESH_MAT_lightmap_light		(AI_IRRMESH_MAT_lightmap|0x10)
-#define AI_IRRMESH_MAT_lightmap_light_m2	(AI_IRRMESH_MAT_lightmap|0x20)
-#define AI_IRRMESH_MAT_lightmap_light_m4	(AI_IRRMESH_MAT_lightmap|0x40)
-#define AI_IRRMESH_MAT_lightmap_add			(AI_IRRMESH_MAT_lightmap|0x80)
-
-// Standard NormalMap (or Parallax map, they're treated equally)
-#define AI_IRRMESH_MAT_normalmap_solid		(0x100)
-
-// Normal map combined with vertex alpha
-#define AI_IRRMESH_MAT_normalmap_tva	\
-	(AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_vertex_alpha)
-
-// Normal map combined with additive transparency
-#define AI_IRRMESH_MAT_normalmap_ta		\
-	(AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_add)
-
-// Special flag. It indicates a second texture has been found
-// Its type depends ... either a normal textue or a normal map
-#define AI_IRRMESH_EXTRA_2ND_TEXTURE		0x100000
-
-
-// ---------------------------------------------------------------------------
-/** Base class for the Irr and IrrMesh importers
- */
-class IrrlichtBase
-{
-protected:
-
-	template <class T>
-	struct Property
-	{
-		std::string name;
-		T value;
-	};
-
-	typedef Property<uint32_t>		HexProperty;
-	typedef Property<std::string>	StringProperty;
-	typedef Property<bool>			BoolProperty;
-	typedef Property<float>			FloatProperty;
-	typedef Property<aiVector3D>	VectorProperty;
-	typedef Property<int>			IntProperty;
-
-	/** XML reader instance
-	 */
-	IrrXMLReader* reader;
-
-
-	// -------------------------------------------------------------------
-	/** Parse a material description from the XML
-	 *  @return The created material
-	 *  @param matFlags Receives AI_IRRMESH_MAT_XX flags
-	 */
-	aiMaterial* ParseMaterial(unsigned int& matFlags);
-
-
-	// -------------------------------------------------------------------
-	/** Read a property of the specified type from the current XML element.
-	 *  @param out Recives output data
-	 */
-	void ReadHexProperty    (HexProperty&    out);
-	void ReadStringProperty (StringProperty& out);
-	void ReadBoolProperty   (BoolProperty&   out);
-	void ReadFloatProperty  (FloatProperty&  out);
-	void ReadVectorProperty (VectorProperty&  out);
-	void ReadIntProperty    (IntProperty&    out);
-};
-
 // ---------------------------------------------------------------------------
 /** IrrMesh importer class.
  *

code/IRRShared.cpp

@@ -0,0 +1,468 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (ASSIMP)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2008, ASSIMP Development Team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the following 
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the ASSIMP team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the ASSIMP Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file  IRRShared.cpp
+ *  @brief Shared utilities for the IRR and IRRMESH loaders
+ */
+
+#include "AssimpPCH.h"
+
+#include "IRRShared.h"
+#include "ParsingUtils.h"
+#include "fast_atof.h"
+
+using namespace Assimp;
+
+// Transformation matrix to convert from Assimp to IRR space
+const aiMatrix4x4 Assimp::AI_TO_IRR_MATRIX = aiMatrix4x4 ( 
+	1.0f, 0.0f, 0.0f, 0.0f, 
+	0.0f, 0.0f, 1.0f, 0.0f,
+	0.0f, 1.0f, 0.0f, 0.0f, 
+	0.0f, 0.0f, 0.0f, 1.0f);
+
+// ------------------------------------------------------------------------------------------------
+// read a property in hexadecimal format (i.e. ffffffff)
+void IrrlichtBase::ReadHexProperty    (HexProperty&    out)
+{
+	for (int i = 0; i < reader->getAttributeCount();++i)
+	{
+		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
+		{
+			out.name = std::string( reader->getAttributeValue(i) );
+		}
+		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
+		{
+			// parse the hexadecimal value
+			out.value = strtol16(reader->getAttributeValue(i));
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a decimal property
+void IrrlichtBase::ReadIntProperty    (IntProperty&    out)
+{
+	for (int i = 0; i < reader->getAttributeCount();++i)
+	{
+		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
+		{
+			out.name = std::string( reader->getAttributeValue(i) );
+		}
+		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
+		{
+			// parse the ecimal value
+			out.value = strtol10s(reader->getAttributeValue(i));
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a string property
+void IrrlichtBase::ReadStringProperty (StringProperty& out)
+{
+	for (int i = 0; i < reader->getAttributeCount();++i)
+	{
+		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
+		{
+			out.name = std::string( reader->getAttributeValue(i) );
+		}
+		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
+		{
+			// simple copy the string
+			out.value = std::string (reader->getAttributeValue(i));
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a boolean property
+void IrrlichtBase::ReadBoolProperty   (BoolProperty&   out)
+{
+	for (int i = 0; i < reader->getAttributeCount();++i)
+	{
+		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
+		{
+			out.name = std::string( reader->getAttributeValue(i) );
+		}
+		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
+		{
+			// true or false, case insensitive
+			out.value = (ASSIMP_stricmp( reader->getAttributeValue(i), 
+				"true") ? false : true);
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a float property
+void IrrlichtBase::ReadFloatProperty  (FloatProperty&  out)
+{
+	for (int i = 0; i < reader->getAttributeCount();++i)
+	{
+		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
+		{
+			out.name = std::string( reader->getAttributeValue(i) );
+		}
+		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
+		{
+			// just parse the float
+			out.value = fast_atof( reader->getAttributeValue(i) );
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a vector property
+void IrrlichtBase::ReadVectorProperty  (VectorProperty&  out)
+{
+	for (int i = 0; i < reader->getAttributeCount();++i)
+	{
+		if (!ASSIMP_stricmp(reader->getAttributeName(i),"name"))
+		{
+			out.name = std::string( reader->getAttributeValue(i) );
+		}
+		else if (!ASSIMP_stricmp(reader->getAttributeName(i),"value"))
+		{
+			// three floats, separated with commas
+			const char* ptr = reader->getAttributeValue(i);
+
+			SkipSpaces(&ptr);
+			ptr = fast_atof_move( ptr,(float&)out.value.x );
+			SkipSpaces(&ptr);
+			if (',' != *ptr)
+			{
+				DefaultLogger::get()->error("IRR(MESH): Expected comma in vector definition");
+			}
+			else SkipSpaces(ptr+1,&ptr);
+			ptr = fast_atof_move( ptr,(float&)out.value.y );
+			SkipSpaces(&ptr);
+			if (',' != *ptr)
+			{
+				DefaultLogger::get()->error("IRR(MESH): Expected comma in vector definition");
+			}
+			else SkipSpaces(ptr+1,&ptr);
+			ptr = fast_atof_move( ptr,(float&)out.value.z );
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert a string to a proper aiMappingMode
+int ConvertMappingMode(const std::string& mode)
+{
+	if (mode == "texture_clamp_repeat")
+	{
+		return aiTextureMapMode_Wrap;
+	}
+	else if (mode == "texture_clamp_mirror")
+		return aiTextureMapMode_Mirror;
+
+	return aiTextureMapMode_Clamp;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a material from the XML file
+aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags)
+{
+	MaterialHelper* mat = new MaterialHelper();
+	aiColor4D clr;
+	aiString s;
+
+	matFlags = 0; // zero output flags
+	int cnt  = 0; // number of used texture channels
+
+	// Continue reading from the file
+	while (reader->read())
+	{
+		switch (reader->getNodeType())
+		{
+		case EXN_ELEMENT:
+
+			// Hex properties
+			if (!ASSIMP_stricmp(reader->getNodeName(),"color"))
+			{
+				HexProperty prop;
+				ReadHexProperty(prop);
+				if (prop.name == "Diffuse")
+				{
+					ColorFromARGBPacked(prop.value,clr);
+					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
+				}
+				else if (prop.name == "Ambient")
+				{
+					ColorFromARGBPacked(prop.value,clr);
+					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_AMBIENT);
+				}
+				else if (prop.name == "Specular")
+				{
+					ColorFromARGBPacked(prop.value,clr);
+					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_SPECULAR);
+				}
+
+				// NOTE: The 'emissive' property causes problems. It is
+				// often != 0, even if there is obviously no light
+				// emitted by the described surface. In fact I think
+				// IRRLICHT ignores this property, too.
+#if 0
+				else if (prop.name == "Emissive")
+				{
+					ColorFromARGBPacked(prop.value,clr);
+					mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
+				}
+#endif
+			}
+			// Float properties
+			else if (!ASSIMP_stricmp(reader->getNodeName(),"float"))
+			{
+				FloatProperty prop;
+				ReadFloatProperty(prop);
+				if (prop.name == "Shininess")
+				{
+					mat->AddProperty(&prop.value,1,AI_MATKEY_SHININESS);
+				}
+			}
+			// Bool properties
+			else if (!ASSIMP_stricmp(reader->getNodeName(),"bool"))
+			{
+				BoolProperty prop;
+				ReadBoolProperty(prop);
+				if (prop.name == "Wireframe")
+				{
+					int val = (prop.value ? true : false);
+					mat->AddProperty(&val,1,AI_MATKEY_ENABLE_WIREFRAME);
+				}
+				else if (prop.name == "GouraudShading")
+				{
+					int val = (prop.value ? aiShadingMode_Gouraud 
+						: aiShadingMode_NoShading);
+					mat->AddProperty(&val,1,AI_MATKEY_SHADING_MODEL);
+				}
+			}
+			// String properties - textures and texture related properties
+			else if (!ASSIMP_stricmp(reader->getNodeName(),"texture") ||
+				     !ASSIMP_stricmp(reader->getNodeName(),"enum"))
+			{
+				StringProperty prop;
+				ReadStringProperty(prop);
+				if (prop.value.length())
+				{
+					// material type (shader)
+					if (prop.name == "Type")
+					{
+						if (prop.value == "trans_vertex_alpha")
+						{
+							matFlags = AI_IRRMESH_MAT_trans_vertex_alpha;
+						}
+						else if (prop.value == "lightmap")
+						{
+							matFlags = AI_IRRMESH_MAT_lightmap;
+						}
+						else if (prop.value == "solid_2layer")
+						{
+							matFlags = AI_IRRMESH_MAT_solid_2layer;
+						}
+						else if (prop.value == "lightmap_m2")
+						{
+							matFlags = AI_IRRMESH_MAT_lightmap_m2;
+						}
+						else if (prop.value == "lightmap_m4")
+						{
+							matFlags = AI_IRRMESH_MAT_lightmap_m4;
+						}
+						else if (prop.value == "lightmap_light")
+						{
+							matFlags = AI_IRRMESH_MAT_lightmap_light;
+						}
+						else if (prop.value == "lightmap_light_m2")
+						{
+							matFlags = AI_IRRMESH_MAT_lightmap_light_m2;
+						}
+						else if (prop.value == "lightmap_light_m4")
+						{
+							matFlags = AI_IRRMESH_MAT_lightmap_light_m4;
+						}
+						else if (prop.value == "lightmap_add")
+						{
+							matFlags = AI_IRRMESH_MAT_lightmap_add;
+						}
+						// Normal and parallax maps are treated equally
+						else if (prop.value == "normalmap_solid" ||
+							prop.value == "parallaxmap_solid")
+						{
+							matFlags = AI_IRRMESH_MAT_normalmap_solid;
+						}
+						else if (prop.value == "normalmap_trans_vertex_alpha" ||
+							prop.value == "parallaxmap_trans_vertex_alpha")
+						{
+							matFlags = AI_IRRMESH_MAT_normalmap_tva;
+						}
+						else if (prop.value == "normalmap_trans_add" ||
+							prop.value == "parallaxmap_trans_add")
+						{
+							matFlags = AI_IRRMESH_MAT_normalmap_ta;
+						}
+					}
+
+					// Up to 4 texture channels are supported
+					else if (prop.name == "Texture1")
+					{
+						// Always accept the primary texture channel
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+					}
+					else if (prop.name == "Texture2")
+					{
+						// 2-layer material lightmapped?
+						if (matFlags & (AI_IRRMESH_MAT_solid_2layer | AI_IRRMESH_MAT_lightmap))
+						{
+							++cnt;
+							s.Set(prop.value);
+							mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(1));
+
+							// set the corresponding material flag
+							matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+						}
+						// alternatively: normal or parallax mapping
+						else if (matFlags & AI_IRRMESH_MAT_normalmap_solid)
+						{
+							++cnt;
+							s.Set(prop.value);
+							mat->AddProperty(&s,AI_MATKEY_TEXTURE_NORMALS(1));
+
+							// set the corresponding material flag
+							matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+						}
+					}
+					else if (prop.name == "Texture3")
+					{
+						// We don't process the third texture channel as Irrlicht
+						// does not seem to use it.
+#if 0
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(2));
+#endif
+					}
+					else if (prop.name == "Texture4" )
+					{
+						// We don't process the fourth texture channel as Irrlicht
+						// does not seem to use it.
+#if 0
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(3));
+#endif
+					}
+
+					// Texture mapping options
+					if (prop.name == "TextureWrap1" && cnt >= 1)
+					{
+						int map = ConvertMappingMode(prop.value);
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
+					}
+					else if (prop.name == "TextureWrap2" && cnt >= 2)
+					{
+						int map = ConvertMappingMode(prop.value);
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1));
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1));	
+					}
+					else if (prop.name == "TextureWrap3" && cnt >= 3)
+					{
+						int map = ConvertMappingMode(prop.value);
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(2));
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(2));
+					}
+					else if (prop.name == "TextureWrap4" && cnt >= 4)
+					{
+						int map = ConvertMappingMode(prop.value);
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(3));
+						mat->AddProperty(&map,1,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(3));
+					}
+				}
+			}
+			break;
+			case EXN_ELEMENT_END:
+
+				/* Assume there are no further nested nodes in <material> elements
+				 */
+				if (/* IRRMESH */ !ASSIMP_stricmp(reader->getNodeName(),"material") ||
+					/* IRR     */ !ASSIMP_stricmp(reader->getNodeName(),"attributes"))
+				{
+					// Now process lightmapping flags
+					// We should have at least one texture, however
+					// if there are multiple textures we assign the
+					// lightmap settings to the last texture.
+					if (cnt && matFlags & AI_IRRMESH_MAT_lightmap)
+					{
+						float f = 1.f;
+
+						// Additive lightmap?
+						int op = (matFlags & AI_IRRMESH_MAT_lightmap_add
+							? aiTextureOp_Add : aiTextureOp_Multiply);
+
+						// Handle Irrlicht's lightmapping scaling factor
+						if (matFlags & AI_IRRMESH_MAT_lightmap_m2 ||
+							matFlags & AI_IRRMESH_MAT_lightmap_light_m2)
+						{
+							f = 2.f;
+						}
+						else if (matFlags & AI_IRRMESH_MAT_lightmap_m4 ||
+							matFlags & AI_IRRMESH_MAT_lightmap_light_m4)
+						{
+							f = 4.f;
+						}
+						mat->AddProperty( &f, 1, AI_MATKEY_TEXBLEND_DIFFUSE(cnt-1));
+						mat->AddProperty( &op,1, AI_MATKEY_TEXOP_DIFFUSE(cnt-1));
+					}
+
+					return mat;
+				}
+			default:
+
+				// GCC complains here ...
+				break;
+		}
+	}
+	DefaultLogger::get()->error("IRRMESH: Unexpected end of file. Material is not complete");
+	return mat;
+}

code/IRRShared.h

@@ -0,0 +1,115 @@
+
+
+/** @file  IRRShared.h
+  * @brief Shared utilities for the IRR and IRRMESH loaders
+  */
+
+#ifndef INCLUDED_AI_IRRSHARED_H
+#define INCLUDED_AI_IRRSHARED_H
+
+#include "irrXMLWrapper.h"
+#include "BaseImporter.h"
+
+namespace Assimp	{
+
+
+/** @brief Matrix to convert from Assimp to IRR and backwards
+ */
+extern const aiMatrix4x4 AI_TO_IRR_MATRIX;
+
+
+// Default: 0 = solid, one texture
+#define AI_IRRMESH_MAT_solid_2layer			0x10000
+
+// Transparency flags
+#define AI_IRRMESH_MAT_trans_vertex_alpha	0x1
+#define AI_IRRMESH_MAT_trans_add			0x2
+
+// Lightmapping flags
+#define AI_IRRMESH_MAT_lightmap				0x2 
+#define AI_IRRMESH_MAT_lightmap_m2			(AI_IRRMESH_MAT_lightmap|0x4)
+#define AI_IRRMESH_MAT_lightmap_m4			(AI_IRRMESH_MAT_lightmap|0x8)
+#define AI_IRRMESH_MAT_lightmap_light		(AI_IRRMESH_MAT_lightmap|0x10)
+#define AI_IRRMESH_MAT_lightmap_light_m2	(AI_IRRMESH_MAT_lightmap|0x20)
+#define AI_IRRMESH_MAT_lightmap_light_m4	(AI_IRRMESH_MAT_lightmap|0x40)
+#define AI_IRRMESH_MAT_lightmap_add			(AI_IRRMESH_MAT_lightmap|0x80)
+
+// Standard NormalMap (or Parallax map, they're treated equally)
+#define AI_IRRMESH_MAT_normalmap_solid		(0x100)
+
+// Normal map combined with vertex alpha
+#define AI_IRRMESH_MAT_normalmap_tva	\
+	(AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_vertex_alpha)
+
+// Normal map combined with additive transparency
+#define AI_IRRMESH_MAT_normalmap_ta		\
+	(AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_add)
+
+// Special flag. It indicates a second texture has been found
+// Its type depends ... either a normal textue or a normal map
+#define AI_IRRMESH_EXTRA_2ND_TEXTURE		0x100000
+
+// ---------------------------------------------------------------------------
+/** Base class for the Irr and IrrMesh importers.
+ *
+ *  Declares some irrlight-related xml parsing utilities and provides tools
+ *  to load materials from IRR and IRRMESH files. 
+ */
+class IrrlichtBase
+{
+protected:
+
+	/** @brief Data structure for a simple name-value property
+	 */
+	template <class T>
+	struct Property
+	{
+		std::string name;
+		T value;
+	};
+
+	typedef Property<uint32_t>		HexProperty;
+	typedef Property<std::string>	StringProperty;
+	typedef Property<bool>			BoolProperty;
+	typedef Property<float>			FloatProperty;
+	typedef Property<aiVector3D>	VectorProperty;
+	typedef Property<int>			IntProperty;
+
+	/** XML reader instance
+	 */
+	IrrXMLReader* reader;
+
+	// -------------------------------------------------------------------
+	/** Parse a material description from the XML
+	 *  @return The created material
+	 *  @param matFlags Receives AI_IRRMESH_MAT_XX flags
+	 */
+	aiMaterial* ParseMaterial(unsigned int& matFlags);
+
+	// -------------------------------------------------------------------
+	/** Read a property of the specified type from the current XML element.
+	 *  @param out Recives output data
+	 */
+	void ReadHexProperty    (HexProperty&    out);
+	void ReadStringProperty (StringProperty& out);
+	void ReadBoolProperty   (BoolProperty&   out);
+	void ReadFloatProperty  (FloatProperty&  out);
+	void ReadVectorProperty (VectorProperty&  out);
+	void ReadIntProperty    (IntProperty&    out);
+};
+
+
+// ------------------------------------------------------------------------------------------------
+// Unpack a hex color, e.g. 0xdcdedfff
+inline void ColorFromARGBPacked(uint32_t in, aiColor4D& clr)
+{
+	clr.a = ((in >> 24) & 0xff) / 255.f;
+	clr.r = ((in >> 16) & 0xff) / 255.f;
+	clr.g = ((in >>  8) & 0xff) / 255.f;
+	clr.b = ((in      ) & 0xff) / 255.f;
+}
+
+
+} // end namespace Assimp
+
+#endif // !! INCLUDED_AI_IRRSHARED_H

code/LWOBLoader.cpp

@@ -42,8 +42,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the LWO importer class for the older LWOB 
     file formats, including materials */
 
-
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
 
 // Internal headers
 #include "LWOLoader.h"
@@ -340,3 +340,5 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
 		mFileBuffer = next;
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_LWO_IMPORTER

code/LWOLoader.cpp

@@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the LWO importer class */
 
 #include "AssimpPCH.h"
-
+#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
 
 // internal headers
 #include "LWOLoader.h"
@@ -57,14 +57,12 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 LWOImporter::LWOImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 LWOImporter::~LWOImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -1243,3 +1241,5 @@ void LWOImporter::LoadLWO2File()
 		mFileBuffer = next;
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_LWO_IMPORTER

code/LWOMaterial.cpp

@@ -43,6 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
 
 // internal headers
 #include "LWOLoader.h"
@@ -819,3 +820,5 @@ void LWOImporter::LoadLWO2Surface(unsigned int size)
 		mFileBuffer = next;
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_X_IMPORTER

code/MD2Loader.cpp

@@ -40,6 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_MD2_IMPORTER
 
 /** @file Implementation of the MD2 importer class */
 #include "MD2Loader.h"
@@ -47,7 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "ByteSwap.h"
 #include "MD2NormalTable.h" // shouldn't be included by other units
 
-
 using namespace Assimp;
 using namespace Assimp::MD2;
 
@@ -422,3 +422,5 @@ void MD2Importer::InternReadFile( const std::string& pFile,
 		pScene->mMeshes[0]->mFaces[i].mIndices[2] = iTemp+0;
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_MD2_IMPORTER

code/MD3Loader.cpp

@@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the MD3 importer class */
 
 #include "AssimpPCH.h"
-
+#ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
 
 #include "MD3Loader.h"
 #include "MaterialSystem.h"
@@ -55,14 +55,12 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 MD3Importer::MD3Importer()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 MD3Importer::~MD3Importer()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -439,3 +437,5 @@ void MD3Importer::InternReadFile(
 	for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
 		pScene->mRootNode->mMeshes[i] = i;
 }
+
+#endif // !! ASSIMP_BUILD_NO_MD3_IMPORTER

code/MD5Loader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the MD5 importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_MD5_IMPORTER
 
 // internal headers
 #include "MaterialSystem.h"
@@ -84,6 +85,7 @@ bool MD5Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
 	if (extension[3] != '5')return false;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure. 
 void MD5Importer::InternReadFile( 
@@ -109,6 +111,7 @@ void MD5Importer::InternReadFile(
 	
 	if (!bHadMD5Mesh)pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
 }
+
 // ------------------------------------------------------------------------------------------------
 void MD5Importer::LoadFileIntoMemory (IOStream* file)
 {
@@ -128,6 +131,7 @@ void MD5Importer::LoadFileIntoMemory (IOStream* file)
 	// now remove all line comments from the file
 	CommentRemover::RemoveLineComments("//",this->mBuffer,' ');
 }
+
 // ------------------------------------------------------------------------------------------------
 void MD5Importer::UnloadFileFromMemory ()
 {
@@ -136,6 +140,7 @@ void MD5Importer::UnloadFileFromMemory ()
 	this->mBuffer = NULL;
 	this->fileSize = 0;
 }
+
 // ------------------------------------------------------------------------------------------------
 void MakeDataUnique (MD5::MeshDesc& meshSrc)
 {
@@ -182,6 +187,7 @@ void MakeDataUnique (MD5::MeshDesc& meshSrc)
 		}
 	}
 }
+
 // ------------------------------------------------------------------------------------------------
 void AttachChilds(int iParentID,aiNode* piParent,BoneList& bones)
 {
@@ -238,6 +244,7 @@ void AttachChilds(int iParentID,aiNode* piParent,BoneList& bones)
 		piParent->mChildren -= piParent->mNumChildren;
 	}
 }
+
 // ------------------------------------------------------------------------------------------------
 void MD5Importer::LoadMD5MeshFile ()
 {
@@ -431,8 +438,9 @@ void MD5Importer::LoadMD5MeshFile ()
 	}
 
 	// delete the file again
-	this->UnloadFileFromMemory();
+	UnloadFileFromMemory();
 }
+
 // ------------------------------------------------------------------------------------------------
 void MD5Importer::LoadMD5AnimFile ()
 {
@@ -448,7 +456,7 @@ void MD5Importer::LoadMD5AnimFile ()
 	bHadMD5Anim = true;
 
 	// now load the file into memory
-	this->LoadFileIntoMemory(file.get());
+	LoadFileIntoMemory(file.get());
 
 	// now construct a parser and parse the file
 	MD5::MD5Parser parser(mBuffer,fileSize);
@@ -558,5 +566,7 @@ void MD5Importer::LoadMD5AnimFile ()
 	}
 
 	// delete the file again
-	this->UnloadFileFromMemory();
+	UnloadFileFromMemory();
 }
+
+#endif // !! ASSIMP_BUILD_NO_MD5_IMPORTER

code/MDCLoader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the MDC importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_MDC_IMPORTER
 
 // internal headers
 #include "MDCLoader.h"
@@ -104,6 +105,7 @@ bool MDCImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
 
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 // Validate the header of the given MDC file
 void MDCImporter::ValidateHeader()
@@ -143,6 +145,7 @@ void MDCImporter::ValidateHeader()
 	if (this->configFrameID >= this->pcHeader->ulNumFrames)
 		throw new ImportErrorException("The requested frame is not available");
 }
+
 // ------------------------------------------------------------------------------------------------
 // Validate the header of a given MDC file surface
 void MDCImporter::ValidateSurfaceHeader(BE_NCONST MDC::Surface* pcSurf)
@@ -175,6 +178,7 @@ void MDCImporter::ValidateSurfaceHeader(BE_NCONST MDC::Surface* pcSurf)
             "are invalid and point somewhere behind the file.");
     }
 }
+
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
 void MDCImporter::SetupProperties(const Importer* pImp)
@@ -187,6 +191,7 @@ void MDCImporter::SetupProperties(const Importer* pImp)
 		this->configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
 	}
 }
+
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure. 
 void MDCImporter::InternReadFile( 
@@ -461,3 +466,5 @@ void MDCImporter::InternReadFile(
 		}
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_MDC_IMPORTER

code/MDLLoader.cpp

@@ -43,15 +43,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // internal headers
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
 
 #include "MDLLoader.h"
 #include "MDLDefaultColorMap.h"
 #include "MD2FileData.h" 
 
-
 using namespace Assimp;
 
-
 // ------------------------------------------------------------------------------------------------
 // macros used by the MDL7 loader
 
@@ -2047,3 +2046,5 @@ void MDLImporter::InternReadFile_HL2( )
 {
 	//const MDL::Header_HL2* pcHeader = (const MDL::Header_HL2*)this->mBuffer;
 }
+
+#endif // !! ASSIMP_BUILD_NO_MDL_IMPORTER

code/MDLMaterialLoader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the material part of the MDL importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
 
 // internal headers
 #include "MDLLoader.h"
@@ -50,10 +51,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
+// Find a suitable pallette file or take teh default one
 void MDLImporter::SearchPalette(const unsigned char** pszColorMap)
 {
 	// now try to find the color map in the current directory
-	IOStream* pcStream = this->pIOHandler->Open(configPalette,"rb");
+	IOStream* pcStream = pIOHandler->Open(configPalette,"rb");
 
 	const unsigned char* szColorMap = (const unsigned char*)::g_aclrDefaultColorMap;
 	if(pcStream)
@@ -70,25 +72,26 @@ void MDLImporter::SearchPalette(const unsigned char** pszColorMap)
 		pcStream = NULL;
 	}
 	*pszColorMap = szColorMap;
-	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Free the palette again
 void MDLImporter::FreePalette(const unsigned char* szColorMap)
 {
 	if (szColorMap != (const unsigned char*)::g_aclrDefaultColorMap)
-	{
 		delete[] szColorMap;
-	}
-	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Check whether we can replace a texture with a single color
 aiColor4D MDLImporter::ReplaceTextureWithColor(const aiTexture* pcTexture)
 {
 	ai_assert(NULL != pcTexture);
 
 	aiColor4D clrOut;
 	clrOut.r = std::numeric_limits<float>::quiet_NaN();
-	if (!pcTexture->mHeight || !pcTexture->mWidth)return clrOut;
+	if (!pcTexture->mHeight || !pcTexture->mWidth)
+		return clrOut;
 
 	const unsigned int iNumPixels = pcTexture->mHeight*pcTexture->mWidth;
 	const aiTexel* pcTexel = pcTexture->pcData+1;
@@ -111,10 +114,12 @@ aiColor4D MDLImporter::ReplaceTextureWithColor(const aiTexture* pcTexture)
 	}
 	return clrOut;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Read a texture from a MDL3 file
 void MDLImporter::CreateTextureARGB8_3DGS_MDL3(const unsigned char* szData)
 {
-	const MDL::Header *pcHeader = (const MDL::Header*)this->mBuffer;  //the endianess is allready corrected in the InternReadFile_3DGS_MDL345 function
+	const MDL::Header *pcHeader = (const MDL::Header*)mBuffer;  //the endianess is allready corrected in the InternReadFile_3DGS_MDL345 function
   
   VALIDATE_FILE_SIZE(szData + pcHeader->skinwidth *
 		pcHeader->skinheight);
@@ -141,20 +146,22 @@ void MDLImporter::CreateTextureARGB8_3DGS_MDL3(const unsigned char* szData)
 		pcNew->pcData[i].b = *sz;
 	}
 
-	this->FreePalette(szColorMap);
+	FreePalette(szColorMap);
 
 	// store the texture
 	aiTexture** pc = this->pScene->mTextures;
-	this->pScene->mTextures = new aiTexture*[this->pScene->mNumTextures+1];
-	for (unsigned int i = 0; i < this->pScene->mNumTextures;++i)
-		this->pScene->mTextures[i] = pc[i];
+	this->pScene->mTextures = new aiTexture*[pScene->mNumTextures+1];
+	for (unsigned int i = 0; i <pScene->mNumTextures;++i)
+		pScene->mTextures[i] = pc[i];
 
-	this->pScene->mTextures[this->pScene->mNumTextures] = pcNew;
-	this->pScene->mNumTextures++;
+	pScene->mTextures[this->pScene->mNumTextures] = pcNew;
+	pScene->mNumTextures++;
 	delete[] pc;
 	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Read a texture from a MDL4 file
 void MDLImporter::CreateTexture_3DGS_MDL4(const unsigned char* szData, 
 	unsigned int iType,
 	unsigned int* piSkip)
@@ -184,25 +191,27 @@ void MDLImporter::CreateTexture_3DGS_MDL4(const unsigned char* szData,
 	{
 		if (!this->pScene->mNumTextures)
 		{
-			this->pScene->mNumTextures = 1;
-			this->pScene->mTextures = new aiTexture*[1];
-			this->pScene->mTextures[0] = pcNew;
+			pScene->mNumTextures = 1;
+			pScene->mTextures = new aiTexture*[1];
+			pScene->mTextures[0] = pcNew;
 		}
 		else
 		{
-			aiTexture** pc = this->pScene->mTextures;
-			this->pScene->mTextures = new aiTexture*[this->pScene->mNumTextures+1];
+			aiTexture** pc = pScene->mTextures;
+			pScene->mTextures = new aiTexture*[pScene->mNumTextures+1];
 			for (unsigned int i = 0; i < this->pScene->mNumTextures;++i)
-				this->pScene->mTextures[i] = pc[i];
-			this->pScene->mTextures[this->pScene->mNumTextures] = pcNew;
-			this->pScene->mNumTextures++;
+				pScene->mTextures[i] = pc[i];
+			pScene->mTextures[pScene->mNumTextures] = pcNew;
+			pScene->mNumTextures++;
 			delete[] pc;
 		}
 	}
 	else delete pcNew;
 	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Load color data of a texture and convert it to our output format
 void MDLImporter::ParseTextureColorData(const unsigned char* szData, 
 	unsigned int iType,
 	unsigned int* piSkip,
@@ -225,9 +234,9 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
 			for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
 			{
 				MDL::RGB565 val = ((MDL::RGB565*)szData)[i];
-        AI_SWAP2(val);    
-				
-        pcNew->pcData[i].a = 0xFF;
+				AI_SWAP2(val);    
+
+				pcNew->pcData[i].a = 0xFF;
 				pcNew->pcData[i].r = (unsigned char)val.b << 3;
 				pcNew->pcData[i].g = (unsigned char)val.g << 2;
 				pcNew->pcData[i].b = (unsigned char)val.r << 3;
@@ -256,7 +265,7 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
 			for (i = 0; i < pcNew->mWidth*pcNew->mHeight;++i)
 			{
 				MDL::ARGB4 val = ((MDL::ARGB4*)szData)[i];
-        AI_SWAP2(val);    
+				AI_SWAP2(val);    
 
 				pcNew->pcData[i].a = (unsigned char)val.a << 4;
 				pcNew->pcData[i].r = (unsigned char)val.r << 4;
@@ -290,9 +299,9 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
 
 				pcNew->pcData[i].a = 0xFF;
 				pcNew->pcData[i].b = *_szData++;
-        pcNew->pcData[i].g = *_szData++;
-		    pcNew->pcData[i].r = *_szData;
-      }
+				pcNew->pcData[i].g = *_szData++;
+				pcNew->pcData[i].r = *_szData;
+			}
 		} 
 		else i = pcNew->mWidth*pcNew->mHeight;
 
@@ -320,10 +329,10 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
 				const unsigned char* _szData = &szData[i*4];
 
 				pcNew->pcData[i].b = *_szData++;
-        pcNew->pcData[i].g = *_szData++;
-        pcNew->pcData[i].r = *_szData++;
-        pcNew->pcData[i].a = *_szData;
-      }
+				pcNew->pcData[i].g = *_szData++;
+				pcNew->pcData[i].r = *_szData++;
+				pcNew->pcData[i].a = *_szData;
+			}
 		} 
 		else i = pcNew->mWidth*pcNew->mHeight;
 
@@ -355,9 +364,9 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
 
 				pcNew->pcData[i].a = 0xFF;
 				pcNew->pcData[i].r = *sz++;
-        pcNew->pcData[i].g = *sz++;
-        pcNew->pcData[i].b = *sz;
-      }
+				pcNew->pcData[i].g = *sz++;
+				pcNew->pcData[i].b = *sz;
+			}
 			this->FreePalette(szColorMap);
 
 		} 
@@ -366,15 +375,15 @@ void MDLImporter::ParseTextureColorData(const unsigned char* szData,
 
 		// FIXME: Also support for MIP maps?
 	}
-	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Get a texture from a MDL5 file
 void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData, 
 	unsigned int iType,
 	unsigned int* piSkip)
 {
 	ai_assert(NULL != piSkip);
-
 	bool bNoRead = *piSkip == 0xffffffff;
 
 	// allocate a new texture object
@@ -384,11 +393,11 @@ void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData,
 
 	// first read the size of the texture
 	pcNew->mWidth = *((uint32_t*)szData);
-  AI_SWAP4(pcNew->mWidth); 
+	AI_SWAP4(pcNew->mWidth); 
 	szData += sizeof(uint32_t);
 
 	pcNew->mHeight = *((uint32_t*)szData);
-  AI_SWAP4(pcNew->mHeight); 
+	AI_SWAP4(pcNew->mHeight); 
 	szData += sizeof(uint32_t);
 
 	if (bNoRead)pcNew->pcData = (aiTexel*)0xffffffff;
@@ -420,7 +429,7 @@ void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData,
 	else
 	{
 		// parse the color data of the texture
-		this->ParseTextureColorData(szData,iType,
+		ParseTextureColorData(szData,iType,
 			piSkip,pcNew);
 	}
 	*piSkip += sizeof(uint32_t) * 2;
@@ -430,26 +439,28 @@ void MDLImporter::CreateTexture_3DGS_MDL5(const unsigned char* szData,
 		// store the texture
 		if (!this->pScene->mNumTextures)
 		{
-			this->pScene->mNumTextures = 1;
-			this->pScene->mTextures = new aiTexture*[1];
-			this->pScene->mTextures[0] = pcNew;
+			pScene->mNumTextures = 1;
+			pScene->mTextures = new aiTexture*[1];
+			pScene->mTextures[0] = pcNew;
 		}
 		else
 		{
-			aiTexture** pc = this->pScene->mTextures;
-			this->pScene->mTextures = new aiTexture*[this->pScene->mNumTextures+1];
-			for (unsigned int i = 0; i < this->pScene->mNumTextures;++i)
+			aiTexture** pc = pScene->mTextures;
+			pScene->mTextures = new aiTexture*[pScene->mNumTextures+1];
+			for (unsigned int i = 0; i < pScene->mNumTextures;++i)
 				this->pScene->mTextures[i] = pc[i];
 
-			this->pScene->mTextures[this->pScene->mNumTextures] = pcNew;
-			this->pScene->mNumTextures++;
+			pScene->mTextures[pScene->mNumTextures] = pcNew;
+			pScene->mNumTextures++;
 			delete[] pc;
 		}
 	}
 	else delete pcNew;
 	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Get a skin from a MDL7 file - more complex than all other subformats
 void MDLImporter::ParseSkinLump_3DGS_MDL7(
 	const unsigned char* szCurrent,
 	const unsigned char** szCurrentOut,
@@ -466,11 +477,6 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 	if (0x1 ==  iMasked)
 	{
 		// ***** REFERENCE TO ANOTHER SKIN INDEX *****
-
-		// NOTE: Documentation - if you can call it a documentation, I prefer
-		// the expression "rubbish" - states it is currently unused. However,
-		// I don't know what ideas the terrible developers of Conitec will
-		// have tomorrow, so Im going to implement it.
 		int referrer = (int)iWidth;
 		pcMatOut->AddProperty<int>(&referrer,1,AI_MDL7_REFERRER_MATERIAL);
 	}
@@ -486,6 +492,8 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 		pcNew = new aiTexture();
 		pcNew->mHeight = 0;
 		pcNew->mWidth = iWidth;
+
+		// place a proper format hint
 		pcNew->achFormatHint[0] = 'd';
 		pcNew->achFormatHint[1] = 'd';
 		pcNew->achFormatHint[2] = 's';
@@ -576,63 +584,65 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 		aiColor3D clrTemp;
 
 #define COLOR_MULTIPLY_RGB() \
-		if (is_not_qnan(clrTexture.r)) \
+	if (is_not_qnan(clrTexture.r)) \
 		{ \
-			clrTemp.r *= clrTexture.r; \
-			clrTemp.g *= clrTexture.g; \
-			clrTemp.b *= clrTexture.b; \
+		clrTemp.r *= clrTexture.r; \
+		clrTemp.g *= clrTexture.g; \
+		clrTemp.b *= clrTexture.b; \
 		}
 
 		// read diffuse color
 		clrTemp.r = pcMatIn->Diffuse.r;
-    AI_SWAP4(clrTemp.r);  
+		AI_SWAP4(clrTemp.r);  
 		clrTemp.g = pcMatIn->Diffuse.g;
-    AI_SWAP4(clrTemp.g);  
+		AI_SWAP4(clrTemp.g);  
 		clrTemp.b = pcMatIn->Diffuse.b;
-    AI_SWAP4(clrTemp.b);  
+		AI_SWAP4(clrTemp.b);  
 		COLOR_MULTIPLY_RGB();
 		pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_DIFFUSE);
 
 		// read specular color
 		clrTemp.r = pcMatIn->Specular.r;
-    AI_SWAP4(clrTemp.r);  
+		AI_SWAP4(clrTemp.r);  
 		clrTemp.g = pcMatIn->Specular.g;
-    AI_SWAP4(clrTemp.g);  
+		AI_SWAP4(clrTemp.g);  
 		clrTemp.b = pcMatIn->Specular.b;
-    AI_SWAP4(clrTemp.b);  
+		AI_SWAP4(clrTemp.b);  
 		COLOR_MULTIPLY_RGB();
 		pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_SPECULAR);
 
 		// read ambient color
 		clrTemp.r = pcMatIn->Ambient.r;
-    AI_SWAP4(clrTemp.r);  
+		AI_SWAP4(clrTemp.r);  
 		clrTemp.g = pcMatIn->Ambient.g;
-    AI_SWAP4(clrTemp.g);  
+		AI_SWAP4(clrTemp.g);  
 		clrTemp.b = pcMatIn->Ambient.b;
-    AI_SWAP4(clrTemp.b);  
+		AI_SWAP4(clrTemp.b);  
 		COLOR_MULTIPLY_RGB();
 		pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_AMBIENT);
 
 		// read emissive color
 		clrTemp.r = pcMatIn->Emissive.r;
-    AI_SWAP4(clrTemp.r);  
+		AI_SWAP4(clrTemp.r);  
 		clrTemp.g = pcMatIn->Emissive.g;
-    AI_SWAP4(clrTemp.g);  
+		AI_SWAP4(clrTemp.g);  
 		clrTemp.b = pcMatIn->Emissive.b;
-    AI_SWAP4(clrTemp.b);  
+		AI_SWAP4(clrTemp.b);  
 		pcMatOut->AddProperty<aiColor3D>(&clrTemp,1,AI_MATKEY_COLOR_EMISSIVE);
 
+#undef COLOR_MULITPLY_RGB
+
 		// FIX: Take the opacity from the ambient color
 		// the doc says something else, but it is fact that MED exports the
 		// opacity like this .... ARRRGGHH!
 		clrTemp.r = pcMatIn->Ambient.a;
-    AI_SWAP4(clrTemp.r);  
+		AI_SWAP4(clrTemp.r);  
 		if (is_not_qnan(clrTexture.r))clrTemp.r *= clrTexture.a;
 		pcMatOut->AddProperty<float>(&clrTemp.r,1,AI_MATKEY_OPACITY);
 
 		// read phong power
 		int iShadingMode = (int)aiShadingMode_Gouraud;
-    AI_SWAP4(pcMatIn->Power);  
+		AI_SWAP4(pcMatIn->Power);  
 		if (0.0f != pcMatIn->Power)
 		{
 			iShadingMode = (int)aiShadingMode_Phong;
@@ -659,12 +669,12 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 	{
 		VALIDATE_FILE_SIZE(szCurrent);
 		int32_t iMe = *((int32_t*)szCurrent);
-    AI_SWAP4(iMe);  
+		AI_SWAP4(iMe);  
 		szCurrent += sizeof(char) * iMe + sizeof(int32_t);
 		VALIDATE_FILE_SIZE(szCurrent);
 	}
 
-	// if an embedded texture has been loaded setup the corresponding
+	// If an embedded texture has been loaded setup the corresponding
 	// data structures in the aiScene instance
 	if (pcNew && this->pScene->mNumTextures <= 999)
 	{
@@ -702,7 +712,9 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 	VALIDATE_FILE_SIZE(szCurrent);
 	*szCurrentOut = szCurrent;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Skip a skin lump
 void MDLImporter::SkipSkinLump_3DGS_MDL7(
 	const unsigned char* szCurrent,
 	const unsigned char** szCurrentOut,
@@ -743,33 +755,11 @@ void MDLImporter::SkipSkinLump_3DGS_MDL7(
 			szCurrent += iSkip;
 		}
 	}
-	
+
 	// check whether a material definition is contained in the skin
 	if (iType & AI_MDL7_SKINTYPE_MATERIAL)
 	{
 		BE_NCONST MDL::Material_MDL7* pcMatIn = (BE_NCONST MDL::Material_MDL7*)szCurrent;
-    AI_SWAP4(pcMatIn->Diffuse.r);  
-    AI_SWAP4(pcMatIn->Diffuse.g);
-    AI_SWAP4(pcMatIn->Diffuse.b);
-    AI_SWAP4(pcMatIn->Diffuse.a);
-    
-    AI_SWAP4(pcMatIn->Ambient.r);  
-    AI_SWAP4(pcMatIn->Ambient.g);
-    AI_SWAP4(pcMatIn->Ambient.b);
-    AI_SWAP4(pcMatIn->Ambient.a);
-
-    AI_SWAP4(pcMatIn->Specular.r);  
-    AI_SWAP4(pcMatIn->Specular.g);
-    AI_SWAP4(pcMatIn->Specular.b);
-    AI_SWAP4(pcMatIn->Specular.a);
-
-    AI_SWAP4(pcMatIn->Emissive.r);  
-    AI_SWAP4(pcMatIn->Emissive.g);
-    AI_SWAP4(pcMatIn->Emissive.b);
-    AI_SWAP4(pcMatIn->Emissive.a);
-    
-    AI_SWAP4(pcMatIn->Power);
-
 		szCurrent = (unsigned char*)(pcMatIn+1);
 	}
 
@@ -778,12 +768,14 @@ void MDLImporter::SkipSkinLump_3DGS_MDL7(
 	if (iType & AI_MDL7_SKINTYPE_MATERIAL_ASCDEF)
 	{
 		int32_t iMe = *((int32_t*)szCurrent);
-    AI_SWAP4(iMe);  
+		AI_SWAP4(iMe);  
 		szCurrent += sizeof(char) * iMe + sizeof(int32_t);
 	}
 	*szCurrentOut = szCurrent;
 }
+
 // ------------------------------------------------------------------------------------------------
+// What the fuck does this function do? Can't remember
 void MDLImporter::ParseSkinLump_3DGS_MDL7(
 	const unsigned char* szCurrent,
 	const unsigned char** szCurrentOut,
@@ -794,8 +786,8 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 
 	*szCurrentOut = szCurrent;
 	BE_NCONST MDL::Skin_MDL7* pcSkin = (BE_NCONST MDL::Skin_MDL7*)szCurrent;
-  AI_SWAP4(pcSkin->width);
-  AI_SWAP4(pcSkin->height); 
+	AI_SWAP4(pcSkin->width);
+	AI_SWAP4(pcSkin->height); 
 	szCurrent += 12;
 
 	// allocate an output material
@@ -805,9 +797,9 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 	// skip length of file name
 	szCurrent += AI_MDL7_MAX_TEXNAMESIZE;
 
-	this->ParseSkinLump_3DGS_MDL7(szCurrent,szCurrentOut,pcMatOut,
+	ParseSkinLump_3DGS_MDL7(szCurrent,szCurrentOut,pcMatOut,
 		pcSkin->typ,pcSkin->width,pcSkin->height);
-	
+
 	// place the name of the skin in the material
 	if (pcSkin->texture_name[0])
 	{
@@ -819,5 +811,6 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
 
 		pcMatOut->AddProperty(&szFile,AI_MATKEY_NAME);
 	}
-	return;
 }
+
+#endif // !! ASSIMP_BUILD_NO_MDL_IMPORTER

code/NFFLoader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the STL importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_NFF_IMPORTER
 
 // internal headers
 #include "NFFLoader.h"
@@ -55,14 +56,12 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 NFFImporter::NFFImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 NFFImporter::~NFFImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -1260,3 +1259,5 @@ void NFFImporter::InternReadFile( const std::string& pFile,
 	}
 	pScene->mRootNode = root;
 }
+
+#endif // !! ASSIMP_BUILD_NO_NFF_IMPORTER

code/OFFLoader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the OFF importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_OFF_IMPORTER
 
 // internal headers
 #include "OFFLoader.h"
@@ -54,14 +55,12 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 OFFImporter::OFFImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 OFFImporter::~OFFImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -197,3 +196,5 @@ void OFFImporter::InternReadFile( const std::string& pFile,
 	pcMat->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
 	pScene->mMaterials[0] = pcMat;
 }
+
+#endif // !! ASSIMP_BUILD_NO_OFF_IMPORTER

code/ObjFileData.h

@@ -148,8 +148,14 @@ struct Material
 {
 	//!	NAme of material description
 	aiString MaterialName;
-	//!	Name of used texture
+
+	//!	Texture names
 	aiString texture;
+	aiString textureSpecular;
+	aiString textureAmbient;
+	aiString textureBump;
+	aiString textureSpecularity;
+
 	//!	Ambient color 
 	aiColor3D ambient;
 	//!	Diffuse color

code/ObjFileImporter.cpp

@@ -40,13 +40,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
 
 #include "ObjFileImporter.h"
 #include "ObjFileParser.h"
 #include "ObjFileData.h"
 
-namespace Assimp
-{
+namespace Assimp	{
 // ------------------------------------------------------------------------------------------------
 
 using namespace std;
@@ -441,6 +441,18 @@ void ObjFileImporter::createMaterial(const ObjFile::Model* pModel, const ObjFile
 		// Adding textures
 		if ( 0 != pCurrentMaterial->texture.length )
 			mat->AddProperty( &pCurrentMaterial->texture, AI_MATKEY_TEXTURE_DIFFUSE(0));
+
+		if ( 0 != pCurrentMaterial->textureAmbient.length )
+			mat->AddProperty( &pCurrentMaterial->textureAmbient, AI_MATKEY_TEXTURE_AMBIENT(0));
+
+		if ( 0 != pCurrentMaterial->textureSpecular.length )
+			mat->AddProperty( &pCurrentMaterial->textureSpecular, AI_MATKEY_TEXTURE_SPECULAR(0));
+
+		if ( 0 != pCurrentMaterial->textureBump.length )
+			mat->AddProperty( &pCurrentMaterial->textureBump, AI_MATKEY_TEXTURE_HEIGHT(0));
+
+		if ( 0 != pCurrentMaterial->textureSpecularity.length )
+			mat->AddProperty( &pCurrentMaterial->textureSpecularity, AI_MATKEY_TEXTURE_SHININESS(0));
 		
 		// Store material property info in material array in scene
 		pScene->mMaterials[ pScene->mNumMaterials ] = mat;
@@ -489,3 +501,5 @@ void ObjFileImporter::appendChildToParentNode(aiNode *pParent, aiNode *pChild)
 // ------------------------------------------------------------------------------------------------
 
 }	// Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER

code/ObjFileMtlImporter.cpp

@@ -40,15 +40,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
 
 #include "ObjFileMtlImporter.h"
 #include "ObjTools.h"
 #include "ObjFileData.h"
 #include "fast_atof.h"
 
-
-namespace Assimp
-{
+namespace Assimp	{
 
 // -------------------------------------------------------------------
 //	Constructor
@@ -152,6 +151,7 @@ void ObjFileMtlImporter::load()
 		
 
 		case 'm':	// Texture
+		case 'b':   // quick'n'dirty - for 'bump' sections
 			{
 				getTexture();
 				m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
@@ -244,14 +244,50 @@ void ObjFileMtlImporter::createMaterial()
 //	Gets a texture name from data.
 void ObjFileMtlImporter::getTexture()
 {
+	aiString* out = NULL;
+
+	// FIXME: just a quick'n'dirty hack, consider cleanup later
+
+	// Diffuse texture
+	if (!ASSIMP_strincmp(&(*m_DataIt),"map_kd",6))
+		out = & m_pModel->m_pCurrentMaterial->texture;
+
+	// Ambient texture
+	else if (!ASSIMP_strincmp(&(*m_DataIt),"map_ka",6))
+		out = & m_pModel->m_pCurrentMaterial->textureAmbient;
+
+	// Specular texture
+	else if (!ASSIMP_strincmp(&(*m_DataIt),"map_ks",6))
+		out = & m_pModel->m_pCurrentMaterial->textureSpecular;
+
+	// Ambient texture
+	else if (!ASSIMP_strincmp(&(*m_DataIt),"map_ka",6))
+		out = & m_pModel->m_pCurrentMaterial->textureAmbient;
+
+	// Bump texture
+	else if (!ASSIMP_strincmp(&(*m_DataIt),"map_bump",8) || !ASSIMP_strincmp(&(*m_DataIt),"bump",4))
+		out = & m_pModel->m_pCurrentMaterial->textureBump;
+
+	// Specularity scaling (glossiness)
+	else if (!ASSIMP_strincmp(&(*m_DataIt),"map_ns",6))
+		out = & m_pModel->m_pCurrentMaterial->textureSpecularity;
+
+	else
+	{
+		DefaultLogger::get()->error("OBJ/MTL: Encountered unknown texture type");
+		return;
+	}
+
 	std::string strTexture;
 	m_DataIt = getName<DataArrayIt>( m_DataIt, m_DataItEnd, strTexture );
 	if ( m_DataItEnd == m_DataIt )
 		return;
 
-	m_pModel->m_pCurrentMaterial->texture.Set( strTexture );
+	out->Set( strTexture );
 }
 
 // -------------------------------------------------------------------
 
 } // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER

code/ObjFileParser.cpp

@@ -40,6 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
 
 #include "ObjFileParser.h"
 #include "ObjFileMtlImporter.h"
@@ -49,10 +50,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "DefaultIOSystem.h"
 
-namespace Assimp
-{
+namespace Assimp	{
 // -------------------------------------------------------------------
-const std::string ObjFileParser::DEFAULT_MATERIAL = "defaultmaterial";
+const std::string ObjFileParser::DEFAULT_MATERIAL = AI_DEFAULT_MATERIAL_NAME; 
+// fix: changed that to our standard default name
 
 // -------------------------------------------------------------------
 //	Constructor with loaded data and directories.
@@ -650,3 +651,5 @@ void ObjFileParser::extractExtension(const std::string &strFile,
 // -------------------------------------------------------------------
 
 }	// Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_OBJ_IMPORTER

code/PlyLoader.cpp

@@ -39,30 +39,28 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-/** @file Implementation of the PLY importer class */
+/** @file  PlyLoader.cpp
+ *  @brief Implementation of the PLY importer class
+ */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_PLY_IMPORTER
 
 // internal headers
 #include "PlyLoader.h"
 #include "MaterialSystem.h"
 
-
-
 using namespace Assimp;
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 PLYImporter::PLYImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 PLYImporter::~PLYImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -76,13 +74,13 @@ bool PLYImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler) const
 	std::string extension = pFile.substr( pos);
 
 	if (extension.length() < 4)return false;
-	if (extension[0] != '.')return false;
+	if (extension[0] != '.')   return false;
 	if (extension[1] != 'p' && extension[1] != 'P')return false;
 	if (extension[2] != 'l' && extension[2] != 'L')return false;
 	if (extension[3] != 'y' && extension[3] != 'Y')return false;
-
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure. 
 void PLYImporter::InternReadFile( 
@@ -104,16 +102,17 @@ void PLYImporter::InternReadFile(
 	// (terminate it with zero)
 	std::vector<unsigned char> mBuffer2(fileSize+1);
 	file->Read( &mBuffer2[0], 1, fileSize);
-	this->mBuffer = &mBuffer2[0];
-	this->mBuffer[fileSize] = '\0';
+	mBuffer = &mBuffer2[0];
+	mBuffer[fileSize] = '\0';
 
-	// the beginning of the file must be PLY
-	if (this->mBuffer[0] != 'P' && this->mBuffer[0] != 'p' ||
-		this->mBuffer[1] != 'L' && this->mBuffer[1] != 'l' ||
-		this->mBuffer[2] != 'Y' && this->mBuffer[2] != 'y')
+	// the beginning of the file must be PLY - magic, magic
+	if (mBuffer[0] != 'P' && mBuffer[0] != 'p' ||
+		mBuffer[1] != 'L' && mBuffer[1] != 'l' ||
+		mBuffer[2] != 'Y' && mBuffer[2] != 'y')
 	{
 		throw new ImportErrorException( "Invalid .ply file: Magic number \'ply\' is no there");
 	}
+
 	char* szMe = (char*)&this->mBuffer[3];
 	SkipSpacesAndLineEnd(szMe,(const char**)&szMe);
 	
@@ -165,11 +164,11 @@ void PLYImporter::InternReadFile(
 
 	// now load a list of normals. 
 	std::vector<aiVector3D> avNormals;
-	this->LoadVertices(&avNormals,true);
+	LoadVertices(&avNormals,true);
 
 	// load the face list
 	std::vector<PLY::Face> avFaces;
-	this->LoadFaces(&avFaces);
+	LoadFaces(&avFaces);
 
 	// if no face list is existing we assume that the vertex
 	// list is containing a list of triangles
@@ -178,10 +177,10 @@ void PLYImporter::InternReadFile(
 		if (avPositions.size() < 3)
 		{
 			throw new ImportErrorException( "Invalid .ply file: Not enough "
-				"vertices to build a face list. ");
+				"vertices to build a proper face list. ");
 		}
 
-		unsigned int iNum = (unsigned int)avPositions.size() / 3;
+		const unsigned int iNum = (unsigned int)avPositions.size() / 3;
 		for (unsigned int i = 0; i< iNum;++i)
 		{
 			PLY::Face sFace;
@@ -194,22 +193,25 @@ void PLYImporter::InternReadFile(
 
 	// now load a list of all materials
 	std::vector<MaterialHelper*> avMaterials;
-	this->LoadMaterial(&avMaterials);
+	LoadMaterial(&avMaterials);
 
 	// now load a list of all vertex color channels
 	std::vector<aiColor4D> avColors;
-	this->LoadVertexColor(&avColors);
+	avColors.reserve(avPositions.size());
+	LoadVertexColor(&avColors);
 
 	// now try to load texture coordinates
 	std::vector<aiVector2D> avTexCoords;
-	this->LoadTextureCoordinates(&avTexCoords);
+	avTexCoords.reserve(avPositions.size());
+	LoadTextureCoordinates(&avTexCoords);
 
 	// now replace the default material in all faces and validate all material indices
-	this->ReplaceDefaultMaterial(&avFaces,&avMaterials);
+	ReplaceDefaultMaterial(&avFaces,&avMaterials);
 
 	// now convert this to a list of aiMesh instances
 	std::vector<aiMesh*> avMeshes;
-	this->ConvertMeshes(&avFaces,&avPositions,&avNormals,
+	avMeshes.reserve(avMaterials.size()+1);
+	ConvertMeshes(&avFaces,&avPositions,&avNormals,
 		&avColors,&avTexCoords,&avMaterials,&avMeshes);
 
 	if (avMeshes.empty())
@@ -235,7 +237,9 @@ void PLYImporter::InternReadFile(
 	for (unsigned int i = 0; i < pScene->mRootNode->mNumMeshes;++i)
 		pScene->mRootNode->mMeshes[i] = i;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Split meshes by material IDs
 void PLYImporter::ConvertMeshes(std::vector<PLY::Face>* avFaces,
 	const std::vector<aiVector3D>*			avPositions,
 	const std::vector<aiVector3D>*			avNormals,
@@ -249,17 +253,12 @@ void PLYImporter::ConvertMeshes(std::vector<PLY::Face>* avFaces,
 	ai_assert(NULL != avMaterials);
 
 	// split by materials
-	std::vector<unsigned int>* aiSplit = new std::vector<unsigned int>[
-		avMaterials->size()];
+	std::vector<unsigned int>* aiSplit = new std::vector<unsigned int>[avMaterials->size()];
 
 	unsigned int iNum = 0;
-	for (std::vector<PLY::Face>::const_iterator
-		i =  avFaces->begin();
-		i != avFaces->end();++i,++iNum)
-	{
-		// index has already been checked
+	for (std::vector<PLY::Face>::const_iterator i = avFaces->begin();i != avFaces->end();++i,++iNum)
 		aiSplit[(*i).iMaterialIndex].push_back(iNum);
-	}
+	
 	// now generate submeshes
 	for (unsigned int p = 0; p < avMaterials->size();++p)
 	{
@@ -294,8 +293,7 @@ void PLYImporter::ConvertMeshes(std::vector<PLY::Face>* avFaces,
 			// add all faces
 			iNum = 0;
 			unsigned int iVertex = 0;
-			for (std::vector<unsigned int>::const_iterator
-				i =  aiSplit[p].begin();
+			for (std::vector<unsigned int>::const_iterator i =  aiSplit[p].begin();
 				i != aiSplit[p].end();++i,++iNum)
 			{
 				p_pcOut->mFaces[iNum].mNumIndices = (unsigned int)(*avFaces)[*i].mIndices.size(); 
@@ -327,12 +325,13 @@ void PLYImporter::ConvertMeshes(std::vector<PLY::Face>* avFaces,
 			avOut->push_back(p_pcOut);
 		}
 	}
-	delete[] aiSplit;
-	return;
+	delete[] aiSplit; // cleanup
 }
+
 // ------------------------------------------------------------------------------------------------
+// Generate a default material if none was specified and apply it to all vanilla faces
 void PLYImporter::ReplaceDefaultMaterial(std::vector<PLY::Face>* avFaces,
-										 std::vector<MaterialHelper*>* avMaterials)
+	std::vector<MaterialHelper*>* avMaterials)
 {
 	bool bNeedDefaultMat = false;
 
@@ -370,8 +369,8 @@ void PLYImporter::ReplaceDefaultMaterial(std::vector<PLY::Face>* avFaces,
 
 		avMaterials->push_back(pcHelper);
 	}
-	return;
 }
+
 // ------------------------------------------------------------------------------------------------
 void PLYImporter::LoadTextureCoordinates(std::vector<aiVector2D>* pvOut)
 {
@@ -384,9 +383,8 @@ void PLYImporter::LoadTextureCoordinates(std::vector<aiVector2D>* pvOut)
 
 	// serach in the DOM for a vertex entry
 	unsigned int _i = 0;
-	for (std::vector<PLY::Element>::const_iterator
-		i =  this->pcDOM->alElements.begin();
-		i != this->pcDOM->alElements.end();++i,++_i)
+	for (std::vector<PLY::Element>::const_iterator i = pcDOM->alElements.begin();
+		i != pcDOM->alElements.end();++i,++_i)
 	{
 		if (PLY::EEST_Vertex == (*i).eSemantic)
 		{
@@ -394,8 +392,7 @@ void PLYImporter::LoadTextureCoordinates(std::vector<aiVector2D>* pvOut)
 
 			// now check whether which normal components are available
 			unsigned int _a = 0;
-			for (std::vector<PLY::Property>::const_iterator
-				a =  (*i).alProperties.begin();
+			for (std::vector<PLY::Property>::const_iterator a =  (*i).alProperties.begin();
 				a != (*i).alProperties.end();++a,++_a)
 			{
 				if ((*a).bIsList)continue;
@@ -418,8 +415,7 @@ void PLYImporter::LoadTextureCoordinates(std::vector<aiVector2D>* pvOut)
 	if (NULL != pcList && 0 != cnt)
 	{
 		pvOut->reserve(pcList->alInstances.size());
-		for (std::vector<ElementInstance>::const_iterator
-			i =  pcList->alInstances.begin();
+		for (std::vector<ElementInstance>::const_iterator i = pcList->alInstances.begin();
 			i != pcList->alInstances.end();++i)
 		{
 			// convert the vertices to sp floats
@@ -441,7 +437,9 @@ void PLYImporter::LoadTextureCoordinates(std::vector<aiVector2D>* pvOut)
 		}
 	}
 }
+
 // ------------------------------------------------------------------------------------------------
+// Try to extract vertices from the PLY DOM
 void PLYImporter::LoadVertices(std::vector<aiVector3D>* pvOut, bool p_bNormals)
 {
 	ai_assert(NULL != pvOut);
@@ -453,21 +451,19 @@ void PLYImporter::LoadVertices(std::vector<aiVector3D>* pvOut, bool p_bNormals)
 
 	// serach in the DOM for a vertex entry
 	unsigned int _i = 0;
-	for (std::vector<PLY::Element>::const_iterator
-		i =  this->pcDOM->alElements.begin();
-		i != this->pcDOM->alElements.end();++i,++_i)
+	for (std::vector<PLY::Element>::const_iterator i =  pcDOM->alElements.begin();
+		i != pcDOM->alElements.end();++i,++_i)
 	{
 		if (PLY::EEST_Vertex == (*i).eSemantic)
 		{
-			pcList = &this->pcDOM->alElementData[_i];
+			pcList = &pcDOM->alElementData[_i];
 
 			// load normal vectors?
 			if (p_bNormals)
 			{
 				// now check whether which normal components are available
 				unsigned int _a = 0;
-				for (std::vector<PLY::Property>::const_iterator
-					a =  (*i).alProperties.begin();
+				for (std::vector<PLY::Property>::const_iterator a = (*i).alProperties.begin();
 					a != (*i).alProperties.end();++a,++_a)
 				{
 					if ((*a).bIsList)continue;
@@ -496,8 +492,7 @@ void PLYImporter::LoadVertices(std::vector<aiVector3D>* pvOut, bool p_bNormals)
 			{
 				// now check whether which coordinate sets are available
 				unsigned int _a = 0;
-				for (std::vector<PLY::Property>::const_iterator
-					a =  (*i).alProperties.begin();
+				for (std::vector<PLY::Property>::const_iterator a = (*i).alProperties.begin();
 					a != (*i).alProperties.end();++a,++_a)
 				{
 					if ((*a).bIsList)continue;
@@ -558,9 +553,10 @@ void PLYImporter::LoadVertices(std::vector<aiVector3D>* pvOut, bool p_bNormals)
 			pvOut->push_back(vOut);
 		}
 	}
-	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Convert a color component to [0...1]
 float PLYImporter::NormalizeColorValue (PLY::PropertyInstance::ValueUnion val,
 	PLY::EDataType eType)
 {
@@ -587,7 +583,9 @@ float PLYImporter::NormalizeColorValue (PLY::PropertyInstance::ValueUnion val,
 	};
 	return 0.0f;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Try to extract proper vertex colors from the PLY DOM
 void PLYImporter::LoadVertexColor(std::vector<aiColor4D>* pvOut)
 {
 	ai_assert(NULL != pvOut);
@@ -599,9 +597,8 @@ void PLYImporter::LoadVertexColor(std::vector<aiColor4D>* pvOut)
 
 	// serach in the DOM for a vertex entry
 	unsigned int _i = 0;
-	for (std::vector<PLY::Element>::const_iterator
-		i =  this->pcDOM->alElements.begin();
-		i != this->pcDOM->alElements.end();++i,++_i)
+	for (std::vector<PLY::Element>::const_iterator i = pcDOM->alElements.begin();
+		i != pcDOM->alElements.end();++i,++_i)
 	{
 		if (PLY::EEST_Vertex == (*i).eSemantic)
 		{
@@ -647,8 +644,7 @@ void PLYImporter::LoadVertexColor(std::vector<aiColor4D>* pvOut)
 	if (NULL != pcList && 0 != cnt)
 	{
 		pvOut->reserve(pcList->alInstances.size());
-		for (std::vector<ElementInstance>::const_iterator
-			i =  pcList->alInstances.begin();
+		for (std::vector<ElementInstance>::const_iterator i = pcList->alInstances.begin();
 			i != pcList->alInstances.end();++i)
 		{
 			// convert the vertices to sp floats
@@ -684,10 +680,10 @@ void PLYImporter::LoadVertexColor(std::vector<aiColor4D>* pvOut)
 			pvOut->push_back(vOut);
 		}
 	}
-	return;
 }
 
 // ------------------------------------------------------------------------------------------------
+// Try to extract proper faces from the PLY DOM
 void PLYImporter::LoadFaces(std::vector<PLY::Face>* pvOut)
 {
 	ai_assert(NULL != pvOut);
@@ -706,17 +702,15 @@ void PLYImporter::LoadFaces(std::vector<PLY::Face>* pvOut)
 
 	// serach in the DOM for a face entry
 	unsigned int _i = 0;
-	for (std::vector<PLY::Element>::const_iterator 
-		i =  this->pcDOM->alElements.begin();
-		i != this->pcDOM->alElements.end();++i,++_i)
+	for (std::vector<PLY::Element>::const_iterator i =  pcDOM->alElements.begin();
+		i != pcDOM->alElements.end();++i,++_i)
 	{
 		// face = unique number of vertex indices
 		if (PLY::EEST_Face == (*i).eSemantic)
 		{
-			pcList = &this->pcDOM->alElementData[_i];
+			pcList = &pcDOM->alElementData[_i];
 			unsigned int _a = 0;
-			for (std::vector<PLY::Property>::const_iterator 
-				a =  (*i).alProperties.begin();
+			for (std::vector<PLY::Property>::const_iterator a =  (*i).alProperties.begin();
 				a != (*i).alProperties.end();++a,++_a)
 			{
 				if (PLY::EST_VertexIndex == (*a).Semantic)
@@ -744,8 +738,7 @@ void PLYImporter::LoadFaces(std::vector<PLY::Face>* pvOut)
 			// find a list property in this ...
 			pcList = &this->pcDOM->alElementData[_i];
 			unsigned int _a = 0;
-			for (std::vector<PLY::Property>::const_iterator 
-				a =  (*i).alProperties.begin();
+			for (std::vector<PLY::Property>::const_iterator a =  (*i).alProperties.begin();
 				a != (*i).alProperties.end();++a,++_a)
 			{
 				// must be a dynamic list!
@@ -765,8 +758,7 @@ void PLYImporter::LoadFaces(std::vector<PLY::Face>* pvOut)
 		if (!bIsTristrip)
 		{
 			pvOut->reserve(pcList->alInstances.size());
-			for (std::vector<ElementInstance>::const_iterator 
-				i =  pcList->alInstances.begin();
+			for (std::vector<ElementInstance>::const_iterator i =  pcList->alInstances.begin();
 				i != pcList->alInstances.end();++i)
 			{
 				PLY::Face sFace;
@@ -797,10 +789,11 @@ void PLYImporter::LoadFaces(std::vector<PLY::Face>* pvOut)
 		}
 		else // triangle strips
 		{
+			// HUGE TODO: MAKE THAT FUCK WORK!
+
 			// normally we have only one triangle strip instance where
 			// a value of -1 indicates a restart of the strip
-			for (std::vector<ElementInstance>::const_iterator
-				i =  pcList->alInstances.begin();
+			for (std::vector<ElementInstance>::const_iterator i =  pcList->alInstances.begin();
 				i != pcList->alInstances.end();++i)
 			{
 				int aiTable[2] = {-1,-1};
@@ -838,9 +831,10 @@ void PLYImporter::LoadFaces(std::vector<PLY::Face>* pvOut)
 			}
 		}
 	}
-	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Get a RGBA color in [0...1] range
 void PLYImporter::GetMaterialColor(const std::vector<PLY::PropertyInstance>& avList,
 	unsigned int aiPositions[4], 
 	PLY::EDataType aiTypes[4],
@@ -876,10 +870,10 @@ void PLYImporter::GetMaterialColor(const std::vector<PLY::PropertyInstance>& avL
 		clrOut->a = NormalizeColorValue(avList[
 			aiPositions[3]].avList.front(),aiTypes[3]);
 	}
-
-	return;
 }
+
 // ------------------------------------------------------------------------------------------------
+// Extract a material from the PLY DOM
 void PLYImporter::LoadMaterial(std::vector<MaterialHelper*>* pvOut)
 {
 	ai_assert(NULL != pvOut);
@@ -905,8 +899,7 @@ void PLYImporter::LoadMaterial(std::vector<MaterialHelper*>* pvOut)
 
 	// serach in the DOM for a vertex entry
 	unsigned int _i = 0;
-	for (std::vector<PLY::Element>::const_iterator
-		i =  this->pcDOM->alElements.begin();
+	for (std::vector<PLY::Element>::const_iterator i =  this->pcDOM->alElements.begin();
 		i != this->pcDOM->alElements.end();++i,++_i)
 	{
 		if (PLY::EEST_Material == (*i).eSemantic)
@@ -1005,8 +998,7 @@ void PLYImporter::LoadMaterial(std::vector<MaterialHelper*>* pvOut)
 	// check whether we have a valid source for the material data
 	if (NULL != pcList)
 	{
-		for (std::vector<ElementInstance>::const_iterator
-			i =  pcList->alInstances.begin();
+		for (std::vector<ElementInstance>::const_iterator i =  pcList->alInstances.begin();
 			i != pcList->alInstances.end();++i)
 		{
 			aiColor4D clrOut;
@@ -1060,5 +1052,6 @@ void PLYImporter::LoadMaterial(std::vector<MaterialHelper*>* pvOut)
 			pvOut->push_back(pcHelper);
 		}
 	}
-	return;
 }
+
+#endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER

code/PlyParser.cpp

@@ -42,12 +42,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the PLY parser class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_PLY_IMPORTER
 
 #include "PlyLoader.h"
 #include "fast_atof.h"
 
-
 using namespace Assimp;
+
 // ------------------------------------------------------------------------------------------------
 PLY::EDataType PLY::Property::ParseDataType(const char* pCur,const char** pCurOut)
 {
@@ -98,6 +99,7 @@ PLY::EDataType PLY::Property::ParseDataType(const char* pCur,const char** pCurOu
 	*pCurOut = pCur;
 	return eOut;
 }
+
 // ------------------------------------------------------------------------------------------------
 PLY::ESemantic PLY::Property::ParseSemantic(const char* pCur,const char** pCurOut)
 {
@@ -237,6 +239,7 @@ PLY::ESemantic PLY::Property::ParseSemantic(const char* pCur,const char** pCurOu
 	*pCurOut = pCur;
 	return eOut;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::Property::ParseProperty (const char* pCur,
 	const char** pCurOut,
@@ -309,6 +312,7 @@ bool PLY::Property::ParseProperty (const char* pCur,
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 PLY::EElementSemantic PLY::Element::ParseSemantic(const char* pCur,
 	const char** pCurOut)
@@ -345,6 +349,7 @@ PLY::EElementSemantic PLY::Element::ParseSemantic(const char* pCur,
 	*pCurOut = pCur;
 	return eOut;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::Element::ParseElement (const char* pCur, 
 	const char** pCurOut,
@@ -399,6 +404,7 @@ bool PLY::Element::ParseElement (const char* pCur,
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::DOM::SkipComments (const char* pCur,
 	const char** pCurOut)
@@ -419,6 +425,7 @@ bool PLY::DOM::SkipComments (const char* pCur,
 	*pCurOut = pCur;
 	return false;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::DOM::ParseHeader (const char* pCur,const char** pCurOut)
 {
@@ -457,6 +464,7 @@ bool PLY::DOM::ParseHeader (const char* pCur,const char** pCurOut)
 	DefaultLogger::get()->debug("PLY::DOM::ParseHeader() succeeded");
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::DOM::ParseElementInstanceLists (
 	const char* pCur,
@@ -483,6 +491,7 @@ bool PLY::DOM::ParseElementInstanceLists (
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::DOM::ParseElementInstanceListsBinary (
 	const char* pCur,
@@ -510,6 +519,7 @@ bool PLY::DOM::ParseElementInstanceListsBinary (
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::DOM::ParseInstanceBinary (const char* pCur,DOM* p_pcOut,bool p_bBE)
 {
@@ -530,6 +540,7 @@ bool PLY::DOM::ParseInstanceBinary (const char* pCur,DOM* p_pcOut,bool p_bBE)
 	DefaultLogger::get()->debug("PLY::DOM::ParseInstanceBinary() succeeded");
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::DOM::ParseInstance (const char* pCur,DOM* p_pcOut)
 {
@@ -552,6 +563,7 @@ bool PLY::DOM::ParseInstance (const char* pCur,DOM* p_pcOut)
 	DefaultLogger::get()->debug("PLY::DOM::ParseInstance() succeeded");
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::ElementInstanceList::ParseInstanceList (
 	const char* pCur,
@@ -584,6 +596,7 @@ bool PLY::ElementInstanceList::ParseInstanceList (
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::ElementInstanceList::ParseInstanceListBinary (
 	const char* pCur,
@@ -606,6 +619,7 @@ bool PLY::ElementInstanceList::ParseInstanceListBinary (
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::ElementInstance::ParseInstance (
 	const char* pCur,
@@ -639,6 +653,7 @@ bool PLY::ElementInstance::ParseInstance (
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::ElementInstance::ParseInstanceBinary (
 	const char* pCur,
@@ -667,6 +682,7 @@ bool PLY::ElementInstance::ParseInstanceBinary (
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::PropertyInstance::ParseInstance (const char* pCur,const char** pCurOut,
 	const PLY::Property* prop, PLY::PropertyInstance* p_pcOut)
@@ -707,6 +723,7 @@ bool PLY::PropertyInstance::ParseInstance (const char* pCur,const char** pCurOut
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::PropertyInstance::ParseInstanceBinary (
 	const char*  pCur,
@@ -743,6 +760,7 @@ bool PLY::PropertyInstance::ParseInstanceBinary (
 	*pCurOut = pCur;
 	return true;
 }
+
 // ------------------------------------------------------------------------------------------------
 PLY::PropertyInstance::ValueUnion PLY::PropertyInstance::DefaultValue(
 	PLY::EDataType eType)
@@ -764,6 +782,7 @@ PLY::PropertyInstance::ValueUnion PLY::PropertyInstance::DefaultValue(
 	out.iUInt = 0;
 	return out;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::PropertyInstance::ParseValue(
 	const char* pCur,
@@ -809,6 +828,7 @@ bool PLY::PropertyInstance::ParseValue(
 	*pCurOut = pCur;
 	return ret;
 }
+
 // ------------------------------------------------------------------------------------------------
 bool PLY::PropertyInstance::ParseValueBinary(
 	const char* pCur,
@@ -827,21 +847,15 @@ bool PLY::PropertyInstance::ParseValueBinary(
 		pCur += 4;
 		
 		// Swap endianess
-		if (p_bBE)
-		{
-			ByteSwap::Swap((int32_t*)&out->iUInt);
-		}
+		if (p_bBE)ByteSwap::Swap((int32_t*)&out->iUInt);
 		break;
 
 	case EDT_UShort:
 		{
-		uint16_t i = *((uint16_t*)pCur);
+		int16_t i = *((uint16_t*)pCur);
 
 		// Swap endianess
-		if (p_bBE)
-		{
-			ByteSwap::Swap((int16_t*)&i);
-		}
+		if (p_bBE)ByteSwap::Swap(&i);
 		out->iUInt = (uint32_t)i;
 		pCur += 2;
 		break;
@@ -849,8 +863,7 @@ bool PLY::PropertyInstance::ParseValueBinary(
 
 	case EDT_UChar:
 		{
-		uint8_t i = *((uint8_t*)pCur);
-		out->iUInt = (uint32_t)i;
+		out->iUInt = (uint32_t)(*((uint8_t*)pCur));
 		pCur ++;
 		break;
 		}
@@ -860,10 +873,7 @@ bool PLY::PropertyInstance::ParseValueBinary(
 		pCur += 4;
 		
 		// Swap endianess
-		if (p_bBE)
-		{
-			ByteSwap::Swap((int32_t*)&out->iInt);
-		}
+		if (p_bBE)ByteSwap::Swap(&out->iInt);
 		break;
 
 	case EDT_Short:
@@ -871,10 +881,7 @@ bool PLY::PropertyInstance::ParseValueBinary(
 		int16_t i = *((int16_t*)pCur);
 
 		// Swap endianess
-		if (p_bBE)
-		{
-			ByteSwap::Swap((int16_t*)&i);
-		}
+		if (p_bBE)ByteSwap::Swap(&i);
 		out->iInt = (int32_t)i;
 		pCur += 2;
 		break;
@@ -887,28 +894,20 @@ bool PLY::PropertyInstance::ParseValueBinary(
 
 	case EDT_Float:
 		{
-		int32_t* pf = (int32_t*)pCur;
+		out->fFloat = *((float*)pCur);
 
 		// Swap endianess
-		if (p_bBE)
-		{
-			ByteSwap::Swap((int32_t*)&pf);
-		}
+		if (p_bBE)ByteSwap::Swap((int32_t*)&out->fFloat);
 		pCur += 4;
-		out->fFloat = *((float*)&pf);
 		break;
 		}
 	case EDT_Double:
 		{
-		int64_t* pf = (int64_t*)pCur;
+		out->fDouble = *((double*)pCur);
 
 		// Swap endianess
-		if (p_bBE)
-		{
-			ByteSwap::Swap((int64_t*)&pf);
-		}
+		if (p_bBE)ByteSwap::Swap((int64_t*)&out->fDouble);
 		pCur += 8;
-		out->fDouble = *((double*)&pf);
 		break;
 		}
 	default:
@@ -917,3 +916,5 @@ bool PLY::PropertyInstance::ParseValueBinary(
 	*pCurOut = pCur;
 	return ret;
 }
+
+#endif // !! ASSIMP_BUILD_NO_PLY_IMPORTER

code/Q3DLoader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the Q3D importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER
 
 // internal headers
 #include "Q3DLoader.h"
@@ -588,3 +589,5 @@ outer:
 		nd->mTransformation = pScene->mRootNode->mChildren[0]->mTransformation;
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_Q3D_IMPORTER

code/RawLoader.cpp

@@ -42,27 +42,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the RAW importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
 
 // internal headers
 #include "RawLoader.h"
 #include "ParsingUtils.h"
 #include "fast_atof.h"
 
-
 using namespace Assimp;
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 RAWImporter::RAWImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 RAWImporter::~RAWImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -317,3 +314,5 @@ void RAWImporter::InternReadFile( const std::string& pFile,
 		}
 	}
 }
+
+#endif // !! ASSIMP_BUILD_NO_RAW_IMPORTER

code/SMDLoader.cpp

@@ -42,6 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the SMD importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_SMD_IMPORTER
 
 // internal headers
 #include "SMDLoader.h"
@@ -1142,3 +1143,5 @@ void SMDImporter::ParseVertex(const char* szCurrent,
 	// go to the beginning of the next line
 	SMDI_PARSE_RETURN;
 }
+
+#endif // !! ASSIMP_BUILD_NO_SMD_IMPORTER

code/STLLoader.cpp

@@ -41,8 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the STL importer class */
 
-
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_STL_IMPORTER
 
 // internal headers
 #include "STLLoader.h"
@@ -55,14 +55,12 @@ using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 STLImporter::STLImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well 
 STLImporter::~STLImporter()
-{
-}
+{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file. 
@@ -386,3 +384,5 @@ bool STLImporter::LoadBinaryFile()
 	}
 	return false;
 }
+
+#endif // !! ASSIMP_BUILD_NO_STL_IMPORTER

code/XFileImporter.cpp

@@ -41,6 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the XFile importer class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_X_IMPORTER
 
 #include "XFileImporter.h"
 #include "XFileParser.h"
@@ -49,10 +50,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 using namespace Assimp;
 
-#if _MSC_VER >= 1400
-#	define sprintf sprintf_s
-#endif
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 XFileImporter::XFileImporter()
@@ -671,3 +668,5 @@ void XFileImporter::ConvertMaterials( aiScene* pScene, const std::vector<XFile::
 	}
 }
 
+#endif // !! ASSIMP_BUILD_NO_X_IMPORTER
+

code/XFileParser.cpp

@@ -42,15 +42,37 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of the XFile parser helper class */
 
 #include "AssimpPCH.h"
+#ifndef ASSIMP_BUILD_NO_X_IMPORTER
 
 #include "XFileParser.h"
 #include "XFileHelper.h"
-#include "BaseImporter.h"
 #include "fast_atof.h"
 
 using namespace Assimp;
 using namespace Assimp::XFile;
 
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_X
+
+#include "../contrib/zlib/zlib.h"
+
+// Magic identifier for MSZIP compressed data
+#define MSZIP_MAGIC 0x4B43
+#define MSZIP_BLOCK 32786
+
+// ------------------------------------------------------------------------------------------------
+// Dummy memory wrappers for use with zlib
+void* dummy_alloc (void* opaque, unsigned int items, unsigned int size)	{
+
+	// we're using calloc to make it easier to debug the whole stuff
+	return ::calloc(items,size);
+}
+
+void  dummy_free  (void* opaque, void* address)	{
+	return ::free(address);
+}
+
+#endif // !! ASSIMP_BUILD_NO_COMPRESSED_X
+
 // ------------------------------------------------------------------------------------------------
 // Constructor. Creates a data structure out of the XFile given in the memory block. 
 XFileParser::XFileParser( const std::vector<char>& pBuffer)
@@ -62,6 +84,9 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
 	mLineNumber = 0;
 	mScene = NULL;
 
+	// vector to store uncompressed file for INFLATE'd X files
+	std::vector<char> uncompressed;
+
 	// set up memory pointers
 	P = &pBuffer.front();
 	End = P + pBuffer.size();
@@ -74,13 +99,30 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
 	mMajorVersion = (unsigned int)(P[4] - 48) * 10 + (unsigned int)(P[5] - 48);
 	mMinorVersion = (unsigned int)(P[6] - 48) * 10 + (unsigned int)(P[7] - 48);
 
-	// read format
+	bool compressed = false;
+
+	// txt - pure ASCII text format
 	if( strncmp( P + 8, "txt ", 4) == 0)
 		mIsBinaryFormat = false;
+
+	// bin - Binary format
 	else if( strncmp( P + 8, "bin ", 4) == 0)
 		mIsBinaryFormat = true;
-	else
-    ThrowException( boost::str( boost::format( "Unsupported xfile format '%c%c%c%c'") % P[8] % P[9] % P[10] % P[11]));
+
+	// tzip - Inflate compressed text format
+	else if( strncmp( P + 8, "tzip", 4) == 0)
+	{
+		mIsBinaryFormat = false;
+		compressed = true;
+	}
+	// bzip - Inflate compressed binary format
+	else if( strncmp( P + 8, "bzip", 4) == 0)
+	{
+		mIsBinaryFormat = true;
+		compressed = true;
+	}
+	else ThrowException( boost::str(boost::format("Unsupported xfile format '%c%c%c%c'") 
+		% P[8] % P[9] % P[10] % P[11]));
 
 	// float size
 	mBinaryFloatSize = (unsigned int)(P[12] - 48) * 1000
@@ -89,11 +131,119 @@ XFileParser::XFileParser( const std::vector<char>& pBuffer)
 		+ (unsigned int)(P[15] - 48);
 
 	if( mBinaryFloatSize != 32 && mBinaryFloatSize != 64)
-		ThrowException( boost::str( boost::format( "Unknown float size %1% specified in xfile header.") % mBinaryFloatSize));
+		ThrowException( boost::str( boost::format( "Unknown float size %1% specified in xfile header.")
+			% mBinaryFloatSize));
 
-	// start reading here
 	P += 16;
-	ReadUntilEndOfLine();
+
+	// If this is a compressed X file, apply the inflate algorithm to it
+	if (compressed)
+	{
+#ifdef ASSIMP_BUILD_NO_COMPRESSED_X
+		throw new ImportErrorException("Assimp was built without compressed X support");
+#else
+		/* ///////////////////////////////////////////////////////////////////////  
+		 * COMPRESSED X FILE FORMAT
+		 * ///////////////////////////////////////////////////////////////////////
+		 *    [xhead]
+		 *    2 major
+		 *    2 minor
+		 *    4 type    // bzip,tzip
+		 *    [mszip_master_head]
+		 *    4 unkn    // checksum?
+		 *    2 unkn    // flags? (seems to be constant)
+		 *    [mszip_head]
+		 *    2 ofs     // offset to next section
+		 *    2 magic   // 'CK'
+		 *    ... ofs bytes of data
+		 *    ... next mszip_head
+		 *
+		 *  http://www.kdedevelopers.org/node/3181 has been very helpful.
+		 * ///////////////////////////////////////////////////////////////////////
+		 */
+
+		// build a zlib stream
+		z_stream stream;
+		stream.opaque = NULL;
+		stream.zalloc = &dummy_alloc;
+		stream.zfree  = &dummy_free;
+		stream.data_type = (mIsBinaryFormat ? Z_BINARY : Z_ASCII);
+
+		// initialize the inflation algorithm
+		::inflateInit2(&stream, -MAX_WBITS);
+
+		// skip unknown data (checksum, flags?)
+		P += 6;
+
+		// First find out how much storage we'll need. Count sections.
+		const char* P1       = P;
+		unsigned int est_out = 0;
+		while (P1 < End)
+		{
+			// read next offset
+			uint16_t ofs = *((uint16_t*)P1);
+			AI_SWAP2(ofs); P1 += 2;
+
+			if (ofs >= MSZIP_BLOCK)
+				throw new ImportErrorException("X: Invalid offset to next MSZIP compressed block");
+
+			// check magic word
+			uint16_t magic = *((uint16_t*)P1);
+			AI_SWAP2(magic); P1 += 2;
+
+			if (magic != MSZIP_MAGIC)
+				throw new ImportErrorException("X: Unsupported compressed format, expected MSZIP header");
+
+			// and advance to the next offset
+			P1 += ofs;
+			est_out += MSZIP_BLOCK; // one decompressed block is 32786 in size
+		}
+		
+		// Allocate storage and do the actual uncompressing
+		uncompressed.resize(est_out);
+		char* out = &uncompressed.front();
+		while (P < End)
+		{
+			uint16_t ofs = *((uint16_t*)P);
+			AI_SWAP2(ofs); 
+			P += 4;
+
+			// push data to the stream
+			stream.next_in   = (Bytef*)P;
+			stream.avail_in  = ofs;
+			stream.next_out  = (Bytef*)out;
+			stream.avail_out = MSZIP_BLOCK;
+
+			// and decompress the data ....
+			int ret = ::inflate( &stream, Z_SYNC_FLUSH );
+			if (ret != Z_OK && ret != Z_STREAM_END)
+				throw new ImportErrorException("X: Failed to decompress MSZIP-compressed data");
+
+			::inflateReset( &stream );
+			::inflateSetDictionary( &stream, (const Bytef*)out , MSZIP_BLOCK - stream.avail_out );
+
+			// and advance to the next offset
+			out +=  MSZIP_BLOCK - stream.avail_out;
+			P   += ofs;
+		}
+
+		// terminate zlib
+		::inflateEnd(&stream);
+		
+		// ok, update pointers to point to the uncompressed file data
+		P = &uncompressed[0];
+		End = out;
+
+		// FIXME: we don't need the compressed data anymore, could release
+		// it already for better memory usage. Consider breaking const-co.
+		DefaultLogger::get()->info("Successfully decompressed MSZIP-compressed file");
+#endif // !! ASSIMP_BUILD_NO_COMPRESSED_X
+	}
+	else
+	{
+		// start reading here
+		ReadUntilEndOfLine();
+	}
 
 	mScene = new Scene;
 	ParseFile();
@@ -1079,6 +1229,9 @@ unsigned int XFileParser::ReadInt()
 	} else
 	{
 		FindNextNoneWhiteSpace();
+
+		// TODO: consider using strtol10s instead???
+
 		// check preceeding minus sign
 		bool isNegative = false;
 		if( *P == '-')
@@ -1102,7 +1255,6 @@ unsigned int XFileParser::ReadInt()
 		}
 		
 		CheckForSeparator();
-
 		return isNegative ? ((unsigned int) -int( number)) : number;
 	}
 }
@@ -1139,7 +1291,7 @@ float XFileParser::ReadFloat()
 	FindNextNoneWhiteSpace();
 	// check for various special strings to allow reading files from faulty exporters
 	// I mean you, Blender!
-	if( strncmp( P, "-1.#IND00", 9) == 0)
+	if( strncmp( P, "-1.#IND00", 9) == 0 || strncmp( P, "1.#IND00", 8) == 0)
 	{ 
 		P += 9;
 		CheckForSeparator();
@@ -1208,6 +1360,7 @@ aiColor3D XFileParser::ReadRGB()
 	return color;
 }
 
+// ------------------------------------------------------------------------------------------------
 // Throws an exception with a line number and the given text.
 void XFileParser::ThrowException( const std::string& pText)
 {
@@ -1245,3 +1398,5 @@ void XFileParser::FilterHierarchy( XFile::Node* pNode)
 	for( unsigned int a = 0; a < pNode->mChildren.size(); a++)
 		FilterHierarchy( pNode->mChildren[a]);
 }
+
+#endif // !! ASSIMP_BUILD_NO_X_IMPORTER

code/irrXML/irrXMLWrapper.h

@@ -1,46 +0,0 @@
-
-#ifndef AI_IRRXML_WRAPPER_H_INCLUDED
-#define AI_IRRXML_WRAPPER_H_INCLUDED
-
-#include "irrXML.h"
-#include "./../../include/IOStream.h"
-
-namespace Assimp {
-using namespace irr;
-using namespace irr::io;
-
-class CIrrXML_IOStreamReader
-{
-public:
-
-	CIrrXML_IOStreamReader(IOStream* _stream)
-		: stream (_stream)
-	{}
-
-	//! virtual destructor
-	virtual ~CIrrXML_IOStreamReader() {};
-
-	//! Reads an amount of bytes from the file.
-	/** \param buffer: Pointer to buffer where to read bytes will be written to.
-	\param sizeToRead: Amount of bytes to read from the file.
-	\return Returns how much bytes were read. */
-	virtual int read(void* buffer, int sizeToRead)
-	{
-		return (int)stream->Read(buffer,1,sizeToRead);
-	}
-
-	//! Returns size of file in bytes
-	virtual int getSize() 
-	{
-		return (int)stream->FileSize();
-	}
-
-private:
-
-	IOStream* stream;
-};
-
-
-} // ! Assimp
-
-#endif

code/irrXMLWrapper.h

@@ -0,0 +1,50 @@
+
+#ifndef INCLUDED_AI_IRRXML_WRAPPER
+#define INCLUDED_AI_IRRXML_WRAPPER
+
+// some long includes ....
+#include "./../contrib/irrXML/irrXML.h"
+#include "./../include/IOStream.h"
+
+namespace Assimp {
+using namespace irr;
+using namespace irr::io;
+
+// ---------------------------------------------------------------------------------
+/** @brief Utility class to make IrrXML work together with our custom IO system
+ *
+ *  See the IrrXML docs for more details.
+ */
+class CIrrXML_IOStreamReader
+{
+public:
+
+	//! Construction from an existing IOStream
+	CIrrXML_IOStreamReader(IOStream* _stream)
+		: stream (_stream)
+	{}
+
+	//! Virtual destructor
+	virtual ~CIrrXML_IOStreamReader() {};
+
+	//!   Reads an amount of bytes from the file.
+	/**  @param buffer:       Pointer to output buffer.
+	 *   @param sizeToRead:   Amount of bytes to read 
+	 *   @return              Returns how much bytes were read.
+	 */
+	virtual int read(void* buffer, int sizeToRead)	{
+		return (int)stream->Read(buffer,1,sizeToRead);
+	}
+
+	//! Returns size of file in bytes
+	virtual int getSize()	{
+		return (int)stream->FileSize();
+	}
+
+private:
+	IOStream* stream;
+}; // ! class CIrrXML_IOStreamReader
+
+} // ! Assimp
+
+#endif // !! INCLUDED_AI_IRRXML_WRAPPER

code/makefile

@@ -1,99 +1,99 @@
-#rough makefile for linux/gnu systems.  requires that boost libs are installed
-#produces shared library output in bin/libassimp.so
-
-
-SOURCES = AssimpPCH.cpp \
-	3DSConverter.cpp \
-	3DSLoader.cpp \
-	aiAssert.cpp \
-	ASELoader.cpp \
-	ASEParser.cpp \
-	Assimp.cpp BaseImporter.cpp BaseProcess.cpp \
-	CalcTangentsProcess.cpp \
-	ConvertToLHProcess.cpp \
-	DefaultIOStream.cpp \
-	DefaultIOSystem.cpp \
-	DefaultLogger.cpp \
-	DXFLoader.cpp \
-	FixNormalsStep.cpp \
-	GenFaceNormalsProcess.cpp \
-	GenVertexNormalsProcess.cpp \
-	HMPLoader.cpp \
-	Importer.cpp \
-	ImproveCacheLocality.cpp \
-	JoinVerticesProcess.cpp \
-	RemoveVCProcess.cpp \
-	LimitBoneWeightsProcess.cpp \
-	LWOBLoader.cpp \
-	LWOLoader.cpp \
-	LWOMaterial.cpp \
-	MaterialSystem.cpp \
-	MD2Loader.cpp \
-	MD3Loader.cpp \
-	MD5Loader.cpp \
-	MD5Parser.cpp \
-	MDCLoader.cpp \
-	MDLLoader.cpp \
-	MDLMaterialLoader.cpp \
-	NFFLoader.cpp \
-	ObjFileImporter.cpp \
-	ObjFileMtlImporter.cpp \
-	ObjFileParser.cpp \
-	PlyLoader.cpp \
-	PlyParser.cpp \
-	PretransformVertices.cpp \
-	RemoveComments.cpp \
-	RemoveRedundantMaterials.cpp \
-	SGSpatialSort.cpp \
-	SMDLoader.cpp \
-	SpatialSort.cpp \
-	SplitLargeMeshes.cpp \
-	StandardShapes.cpp \
-	STLLoader.cpp \
-	TextureTransform.cpp \
-	TriangulateProcess.cpp \
-	ValidateDataStructure.cpp \
-	VertexTriangleAdjacency.cpp \
-	XFileImporter.cpp \
-	RawLoader.cpp \
-	OFFLoader.cpp \
-	SortByPTypeProcess.cpp \
-	FindInvalidDataProcess.cpp \
-	ACLoader.cpp \
-	LWSLoader.cpp \
-	BVHLoader.cpp \
-	SceneCombiner.cpp \
-	SkeletonMeshBuilder.cpp \
-	FindDegenerates.cpp \
-	XFileParser.cpp \
-	./irrXML/irrXML.cpp \
-	IRRMeshLoader.cpp \
-	IRRLoader.cpp \
-	Q3DLoader.cpp \
-	ScenePreprocessor.cpp \
-	B3DImporter.cpp \
-	TargetAnimation.cpp \
-	ComputeUVMappingProcess.cpp  \
-	ColladaLoader.cpp \
-	ColladaParser.cpp \
-	TerragenLoader.cpp 
-
-OBJECTS = $(SOURCES:.cpp=.o)
-
-TARGET = ./../bin/libassimp.so
-
-all:	$(TARGET)
-
-$(TARGET):	$(OBJECTS)
-	gcc -o $@ $(OBJECTS) -shared -lstdc++ 
+
+# UNTESTED!!!!
+
+# Makefile for Open Asset Import Library (GNU-make)
+# [email protected]
+
+#
+# Usage: make <target> <macros>
+
+# TARGETS:
+#   all                  Build a shared so from the whole library
+#   clean                Cleanup object files, prepare for rebuild
+#   static               Build a static library (*.a)
+
+# MACROS: (make clean before you change one)
+#   NOBOOST=1            Build against boost workaround
+#   SINGLETHREADED=1     Build single-threaded library
+#   DEBUG=1              Build debug build of library
+# 
+
+# C++ object files
+OBJECTS   := $(patsubst %.cpp,%.o,  $(wildcard *.cpp)) 
+OBJECTS   += $(patsubst %.cpp,%.o,  $(wildcard extra/*.cpp)) 
+OBJECTS   += $(patsubst %.cpp,%.o,  $(wildcard ./../contrib/irrXML/*.cpp)) 
+
+# C object files (mainly from zlib)
+OBJECTSC  := $(patsubst %.c,%.oc,   $(wildcard ./../contrib/zlib/*.c))
+
+# Include flags for gcc
+INCLUDEFLAGS =
+
+# Preprocessor defines for gcc
+DEFINEFLAGS = 
+
+# Suffix for the output binary, represents build type
+NAMESUFFIX = 
+
+# Output path for binaries
+BINPATH = ../bin/mingw/
+
+# GCC compiler flags 
+CPPFLAGS=-Wall 
+
+# Setup environment for noboost build
+ifeq ($(NOBOOST),1)
+	SINGLETHREADED = 1
+	INCLUDEFLAGS  += -I../include/BoostWorkaround/
+	DEFINEFLAGS   += -DASSIMP_BUILD_BOOST_WORKAROUND 
+#	NAMESUFFIX    += -noboost
+# else
+#	INCLUDEFLAGS  += -I"C:/Program Files/boost/boost_1_35_0"
+endif
+
+# Setup environment for st build
+ifeq ($(SINGLETHREADED),1)
+	DEFINEFLAGS   += -DASSIMP_BUILD_SINGLETHREADED
+#	NAMESUFFIX    += -st
+endif
+
+# Setup environment for debug build
+ifeq ($(DEBUG),1)
+	DEFINEFLAGS   += -D_DEBUG -DDEBUG
+#	NAMESUFFIX    += -debug
+else
+	CPPFLAGS      += -o3
+	DEFINEFLAGS   += -DNDEBUG -D_NDEBUG
+endif
+
+# Output name of shared library
+SHARED_TARGET = $(BINPATH)/libassimp$(NAMESUFFIX).so
+
+# Output name of static library
+STATIC = $(BINPATH)/libassimp$(NAMESUFFIX).a
+
+# target: all
+# usage : build a shared library (*.so)
+all:	$(SHARED_TARGET)
+
+$(SHARED_TARGET):  $(OBJECTS)  $(OBJECTSC)
+	gcc -o $@ $(OBJECTS) $(OBJECTSC) -shared -lstdc++ 
 %.o:%.cpp
-	$(CXX) -g -Wall -c $? -o $@ -I../include -I"C:\Program Files\boost\boost_1_35_0" -fPIC
+	$(CXX) -g -c  $(CPPFLAGS) $? -o $@ $(INCLUDEFLAGS) $(DEFINEFLAGS) -fPIC
+%.oc:%.c
+	$(CXX) -x c -g -c -ansi $(CPPFLAGS) $? -o $@ -fPIC
+
+# target: clean
+# usage : cleanup all object files, prepare for a rebuild
+.PHONY: clean
 clean:
-	rm -f $(OBJECTS) $(TARGET)
+	-rm -f $(OBJECTS) $(OBJECTSC) $(TARGET)
+
+# target: static
+# usage : build a static library (*.a)
+static:    $(STATIC) 
+$(STATIC):    $(OBJECTS) $(OBJECTSC)
+	ar rcs $@ $(OBJECTS) $(OBJECTSC)
 
 
-STATIC = ./../bin/libassimp.a
-static:    $(STATIC)
-$(STATIC):    $(OBJECTS)
-	ar rcs $@ $(OBJECTS)
 

code/makefile.mingw

@@ -1,99 +1,95 @@
-#rough makefile for build with mingw
-#produces shared library output in bin/libassimp.so
-
-
-SOURCES = AssimpPCH.cpp \
-	3DSConverter.cpp \
-	3DSLoader.cpp \
-	aiAssert.cpp \
-	ASELoader.cpp \
-	ASEParser.cpp \
-	Assimp.cpp BaseImporter.cpp BaseProcess.cpp \
-	CalcTangentsProcess.cpp \
-	ConvertToLHProcess.cpp \
-	DefaultIOStream.cpp \
-	DefaultIOSystem.cpp \
-	DefaultLogger.cpp \
-	DXFLoader.cpp \
-	FixNormalsStep.cpp \
-	GenFaceNormalsProcess.cpp \
-	GenVertexNormalsProcess.cpp \
-	HMPLoader.cpp \
-	Importer.cpp \
-	ImproveCacheLocality.cpp \
-	JoinVerticesProcess.cpp \
-	RemoveVCProcess.cpp \
-	LimitBoneWeightsProcess.cpp \
-	LWOBLoader.cpp \
-	LWOLoader.cpp \
-	LWOMaterial.cpp \
-	MaterialSystem.cpp \
-	MD2Loader.cpp \
-	MD3Loader.cpp \
-	MD5Loader.cpp \
-	MD5Parser.cpp \
-	MDCLoader.cpp \
-	MDLLoader.cpp \
-	MDLMaterialLoader.cpp \
-	NFFLoader.cpp \
-	ObjFileImporter.cpp \
-	ObjFileMtlImporter.cpp \
-	ObjFileParser.cpp \
-	PlyLoader.cpp \
-	PlyParser.cpp \
-	PretransformVertices.cpp \
-	RemoveComments.cpp \
-	RemoveRedundantMaterials.cpp \
-	SGSpatialSort.cpp \
-	SMDLoader.cpp \
-	SpatialSort.cpp \
-	SplitLargeMeshes.cpp \
-	StandardShapes.cpp \
-	STLLoader.cpp \
-	TextureTransform.cpp \
-	TriangulateProcess.cpp \
-	ValidateDataStructure.cpp \
-	VertexTriangleAdjacency.cpp \
-	XFileImporter.cpp \
-	RawLoader.cpp \
-	OFFLoader.cpp \
-	SortByPTypeProcess.cpp \
-	FindInvalidDataProcess.cpp \
-	ACLoader.cpp \
-	LWSLoader.cpp \
-	XFileParser.cpp \
-	SceneCombiner.cpp \
-	FindDegenerates.cpp \
-	SkeletonMeshBuilder.cpp \
-	BVHLoader.cpp \
-	./irrXML/irrXML.cpp \
-	IRRMeshLoader.cpp \
-	IRRLoader.cpp \
-	Q3DLoader.cpp \
-	ScenePreprocessor.cpp \
-	B3DImporter.cpp \
-	TargetAnimation.cpp \
-	ComputeUVMappingProcess.cpp \
-	ColladaLoader.cpp \
-	ColladaParser.cpp \
-	TerragenLoader.cpp 
-
-OBJECTS = $(SOURCES:.cpp=.o)
-
-TARGET = ./../bin/libassimp.so
-
-all:	$(TARGET)
-
-$(TARGET):	$(OBJECTS)
-	gcc -o $@ $(OBJECTS) -shared -lstdc++ 
+
+# Makefile for Open Asset Import Library (MinGW32-make)
+# [email protected]
+#   - just a quick'n'dirty one, could be buggy ...
+#
+# Usage: mingw32-make -f makefile.mingw <target> <macros>
+
+# TARGETS:
+#   all                  Build a shared so from the whole library
+#   clean                Cleanup object files, prepare for rebuild
+#   static               Build a static library (*.a)
+
+# MACROS: (make clean before you change one)
+#   NOBOOST=1            Build against boost workaround
+#   SINGLETHREADED=1     Build single-threaded library
+#   DEBUG=1              Build debug build of library
+# 
+
+# C++ object files
+OBJECTS   := $(patsubst %.cpp,%.o,  $(wildcard *.cpp)) 
+OBJECTS   += $(patsubst %.cpp,%.o,  $(wildcard extra/*.cpp)) 
+OBJECTS   += $(patsubst %.cpp,%.o,  $(wildcard ./../contrib/irrXML/*.cpp)) 
+
+# C object files (mainly from zlib)
+OBJECTSC  := $(patsubst %.c,%.oc,   $(wildcard ./../contrib/zlib/*.c))
+
+# Include flags for gcc
+INCLUDEFLAGS =
+
+# Preprocessor defines for gcc
+DEFINEFLAGS = 
+
+# Suffix for the output binary, represents build type
+NAMESUFFIX = 
+
+# Output path for binaries
+BINPATH = ../bin/mingw/
+
+# GCC compiler flags 
+CPPFLAGS=-Wall 
+
+# Setup environment for noboost build
+ifeq ($(NOBOOST),1)
+	SINGLETHREADED = 1
+	INCLUDEFLAGS  += -I../include/BoostWorkaround/
+	DEFINEFLAGS   += -DASSIMP_BUILD_BOOST_WORKAROUND 
+#	NAMESUFFIX    += -noboost
+else
+	INCLUDEFLAGS  += -I"C:/Program Files/boost/boost_1_35_0"
+endif
+
+# Setup environment for st build
+ifeq ($(SINGLETHREADED),1)
+	DEFINEFLAGS   += -DASSIMP_BUILD_SINGLETHREADED
+#	NAMESUFFIX    += -st
+endif
+
+# Setup environment for debug build
+ifeq ($(DEBUG),1)
+	DEFINEFLAGS   += -D_DEBUG -DDEBUG
+#	NAMESUFFIX    += -debug
+else
+	CPPFLAGS      += -o3
+	DEFINEFLAGS   += -DNDEBUG -D_NDEBUG
+endif
+
+# Output name of shared library
+SHARED_TARGET = $(BINPATH)/libassimp$(NAMESUFFIX).so
+
+# Output name of static library
+STATIC = $(BINPATH)/libassimp$(NAMESUFFIX).a
+
+# target: all
+# usage : build a shared library (*.so)
+all:	$(SHARED_TARGET)
+
+$(SHARED_TARGET):  $(OBJECTS)  $(OBJECTSC)
+	gcc -o $@ $(OBJECTS) $(OBJECTSC) -shared -lstdc++ 
 %.o:%.cpp
-	$(CXX) -g -Wall -c $? -o $@ -I../include -I"C:\Program Files\boost\boost_1_35_0"
-clean:
-	del *.o
+	$(CXX) -g -c  $(CPPFLAGS) $? -o $@ $(INCLUDEFLAGS) $(DEFINEFLAGS)
+%.oc:%.c
+	$(CXX) -x c -g -c -ansi $(CPPFLAGS) $? -o $@ 
 
+# target: clean
+# usage : cleanup all object files, prepare for a rebuild
+.PHONY: clean
+clean:
+	-del *.o .\..\contrib\irrXML\*.o .\..\contrib\zlib\*.oc
 
-STATIC = ./../bin/libassimp.a
-static:    $(STATIC)
-$(STATIC):    $(OBJECTS)
-	ar rcs $@ $(OBJECTS)
+# target: static
+# usage : build a static library (*.a)
+static:    $(STATIC) 
+$(STATIC):    $(OBJECTS) $(OBJECTSC)
+	ar rcs $@ $(OBJECTS) $(OBJECTSC)
 

code/irrXML/CXMLReaderImpl.h → contrib/irrXML/CXMLReaderImpl.h

@@ -8,7 +8,6 @@
 #include "irrXML.h"
 #include "irrString.h"
 #include "irrArray.h"
-#include "./../fast_atof.h"
 
 using namespace Assimp;
 

code/irrXML/irrXML.cpp → contrib/irrXML/irrXML.cpp

@@ -3,14 +3,14 @@
 // For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
 
 // Need to include Assimp, too. We're using Assimp's version of fast_atof
-// so we need stdint.h
+// so we need stdint.h. But no PCH.
 
-#include "./../AssimpPCH.h"
+#include "./../../code/AssimpPCH.h"
 
 #include "irrXML.h"
 #include "irrString.h"
 #include "irrArray.h"
-#include "./../fast_atof.h"
+#include "./../../code/fast_atof.h"
 #include "CXMLReaderImpl.h"
 
 namespace irr

contrib/irrXML_note.txt

@@ -0,0 +1,6 @@
+
+IrrXML
+Downloaded September 2008
+
+- fixed a minor compiler warning (vs 2005, shift too large)
+- fixed an issue regarding wchar_t/unsigned short

contrib/zlib/README

@@ -0,0 +1,125 @@
+ZLIB DATA COMPRESSION LIBRARY
+
+zlib 1.2.3 is a general purpose data compression library.  All the code is
+thread safe.  The data format used by the zlib library is described by RFCs
+(Request for Comments) 1950 to 1952 in the files
+http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format)
+and rfc1952.txt (gzip format). These documents are also available in other
+formats from ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
+
+All functions of the compression library are documented in the file zlib.h
+(volunteer to write man pages welcome, contact [email protected]). A usage example
+of the library is given in the file example.c which also tests that the library
+is working correctly. Another example is given in the file minigzip.c. The
+compression library itself is composed of all source files except example.c and
+minigzip.c.
+
+To compile all files and run the test program, follow the instructions given at
+the top of Makefile. In short "make test; make install" should work for most
+machines. For Unix: "./configure; make test; make install". For MSDOS, use one
+of the special makefiles such as Makefile.msc. For VMS, use make_vms.com.
+
+Questions about zlib should be sent to <[email protected]>, or to Gilles Vollant
+<[email protected]> for the Windows DLL version. The zlib home page is
+http://www.zlib.org or http://www.gzip.org/zlib/ Before reporting a problem,
+please check this site to verify that you have the latest version of zlib;
+otherwise get the latest version and check whether the problem still exists or
+not.
+
+PLEASE read the zlib FAQ http://www.gzip.org/zlib/zlib_faq.html before asking
+for help.
+
+Mark Nelson <[email protected]> wrote an article about zlib for the Jan. 1997
+issue of  Dr. Dobb's Journal; a copy of the article is available in
+http://dogma.net/markn/articles/zlibtool/zlibtool.htm
+
+The changes made in version 1.2.3 are documented in the file ChangeLog.
+
+Unsupported third party contributions are provided in directory "contrib".
+
+A Java implementation of zlib is available in the Java Development Kit
+http://java.sun.com/j2se/1.4.2/docs/api/java/util/zip/package-summary.html
+See the zlib home page http://www.zlib.org for details.
+
+A Perl interface to zlib written by Paul Marquess <[email protected]> is in the
+CPAN (Comprehensive Perl Archive Network) sites
+http://www.cpan.org/modules/by-module/Compress/
+
+A Python interface to zlib written by A.M. Kuchling <[email protected]> is
+available in Python 1.5 and later versions, see
+http://www.python.org/doc/lib/module-zlib.html
+
+A zlib binding for TCL written by Andreas Kupries <[email protected]> is
+availlable at http://www.oche.de/~akupries/soft/trf/trf_zip.html
+
+An experimental package to read and write files in .zip format, written on top
+of zlib by Gilles Vollant <[email protected]>, is available in the
+contrib/minizip directory of zlib.
+
+
+Notes for some targets:
+
+- For Windows DLL versions, please see win32/DLL_FAQ.txt
+
+- For 64-bit Irix, deflate.c must be compiled without any optimization. With
+  -O, one libpng test fails. The test works in 32 bit mode (with the -n32
+  compiler flag). The compiler bug has been reported to SGI.
+
+- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
+  when compiled with cc.
+
+- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
+  necessary to get gzprintf working correctly. This is done by configure.
+
+- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
+  other compilers. Use "make test" to check your compiler.
+
+- gzdopen is not supported on RISCOS, BEOS and by some Mac compilers.
+
+- For PalmOs, see http://palmzlib.sourceforge.net/
+
+- When building a shared, i.e. dynamic library on Mac OS X, the library must be
+  installed before testing (do "make install" before "make test"), since the
+  library location is specified in the library.
+
+
+Acknowledgments:
+
+  The deflate format used by zlib was defined by Phil Katz. The deflate
+  and zlib specifications were written by L. Peter Deutsch. Thanks to all the
+  people who reported problems and suggested various improvements in zlib;
+  they are too numerous to cite here.
+
+Copyright notice:
+
+ (C) 1995-2004 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  [email protected]          [email protected]
+
+If you use the zlib library in a product, we would appreciate *not*
+receiving lengthy legal documents to sign. The sources are provided
+for free but without warranty of any kind.  The library has been
+entirely written by Jean-loup Gailly and Mark Adler; it does not
+include third-party code.
+
+If you redistribute modified sources, we would appreciate that you include
+in the file ChangeLog history information documenting your changes. Please
+read the FAQ for more information on the distribution of modified source
+versions.

contrib/zlib/adler32.c

@@ -0,0 +1,149 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#define BASE 65521UL    /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware */
+#ifdef NO_DIVIDE
+#  define MOD(a) \
+    do { \
+        if (a >= (BASE << 16)) a -= (BASE << 16); \
+        if (a >= (BASE << 15)) a -= (BASE << 15); \
+        if (a >= (BASE << 14)) a -= (BASE << 14); \
+        if (a >= (BASE << 13)) a -= (BASE << 13); \
+        if (a >= (BASE << 12)) a -= (BASE << 12); \
+        if (a >= (BASE << 11)) a -= (BASE << 11); \
+        if (a >= (BASE << 10)) a -= (BASE << 10); \
+        if (a >= (BASE << 9)) a -= (BASE << 9); \
+        if (a >= (BASE << 8)) a -= (BASE << 8); \
+        if (a >= (BASE << 7)) a -= (BASE << 7); \
+        if (a >= (BASE << 6)) a -= (BASE << 6); \
+        if (a >= (BASE << 5)) a -= (BASE << 5); \
+        if (a >= (BASE << 4)) a -= (BASE << 4); \
+        if (a >= (BASE << 3)) a -= (BASE << 3); \
+        if (a >= (BASE << 2)) a -= (BASE << 2); \
+        if (a >= (BASE << 1)) a -= (BASE << 1); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#  define MOD4(a) \
+    do { \
+        if (a >= (BASE << 4)) a -= (BASE << 4); \
+        if (a >= (BASE << 3)) a -= (BASE << 3); \
+        if (a >= (BASE << 2)) a -= (BASE << 2); \
+        if (a >= (BASE << 1)) a -= (BASE << 1); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#else
+#  define MOD(a) a %= BASE
+#  define MOD4(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    unsigned long sum2;
+    unsigned n;
+
+    /* split Adler-32 into component sums */
+    sum2 = (adler >> 16) & 0xffff;
+    adler &= 0xffff;
+
+    /* in case user likes doing a byte at a time, keep it fast */
+    if (len == 1) {
+        adler += buf[0];
+        if (adler >= BASE)
+            adler -= BASE;
+        sum2 += adler;
+        if (sum2 >= BASE)
+            sum2 -= BASE;
+        return adler | (sum2 << 16);
+    }
+
+    /* initial Adler-32 value (deferred check for len == 1 speed) */
+    if (buf == Z_NULL)
+        return 1L;
+
+    /* in case short lengths are provided, keep it somewhat fast */
+    if (len < 16) {
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        if (adler >= BASE)
+            adler -= BASE;
+        MOD4(sum2);             /* only added so many BASE's */
+        return adler | (sum2 << 16);
+    }
+
+    /* do length NMAX blocks -- requires just one modulo operation */
+    while (len >= NMAX) {
+        len -= NMAX;
+        n = NMAX / 16;          /* NMAX is divisible by 16 */
+        do {
+            DO16(buf);          /* 16 sums unrolled */
+            buf += 16;
+        } while (--n);
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* do remaining bytes (less than NMAX, still just one modulo) */
+    if (len) {                  /* avoid modulos if none remaining */
+        while (len >= 16) {
+            len -= 16;
+            DO16(buf);
+            buf += 16;
+        }
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* return recombined sums */
+    return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off_t len2;
+{
+    unsigned long sum1;
+    unsigned long sum2;
+    unsigned rem;
+
+    /* the derivation of this formula is left as an exercise for the reader */
+    rem = (unsigned)(len2 % BASE);
+    sum1 = adler1 & 0xffff;
+    sum2 = rem * sum1;
+    MOD(sum2);
+    sum1 += (adler2 & 0xffff) + BASE - 1;
+    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+    if (sum1 > BASE) sum1 -= BASE;
+    if (sum1 > BASE) sum1 -= BASE;
+    if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
+    if (sum2 > BASE) sum2 -= BASE;
+    return sum1 | (sum2 << 16);
+}

contrib/zlib/crc32.c

@@ -0,0 +1,423 @@
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <[email protected]> for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors.  This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+/* @(#) $Id$ */
+
+/*
+  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+  protection on the static variables used to control the first-use generation
+  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+  first call get_crc_table() to initialize the tables before allowing more than
+  one thread to use crc32().
+ */
+
+#ifdef MAKECRCH
+#  include <stdio.h>
+#  ifndef DYNAMIC_CRC_TABLE
+#    define DYNAMIC_CRC_TABLE
+#  endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h"      /* for STDC and FAR definitions */
+
+#define local static
+
+/* Find a four-byte integer type for crc32_little() and crc32_big(). */
+#ifndef NOBYFOUR
+#  ifdef STDC           /* need ANSI C limits.h to determine sizes */
+#    include <limits.h>
+#    define BYFOUR
+#    if (UINT_MAX == 0xffffffffUL)
+       typedef unsigned int u4;
+#    else
+#      if (ULONG_MAX == 0xffffffffUL)
+         typedef unsigned long u4;
+#      else
+#        if (USHRT_MAX == 0xffffffffUL)
+           typedef unsigned short u4;
+#        else
+#          undef BYFOUR     /* can't find a four-byte integer type! */
+#        endif
+#      endif
+#    endif
+#  endif /* STDC */
+#endif /* !NOBYFOUR */
+
+/* Definitions for doing the crc four data bytes at a time. */
+#ifdef BYFOUR
+#  define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \
+                (((w)&0xff00)<<8)+(((w)&0xff)<<24))
+   local unsigned long crc32_little OF((unsigned long,
+                        const unsigned char FAR *, unsigned));
+   local unsigned long crc32_big OF((unsigned long,
+                        const unsigned char FAR *, unsigned));
+#  define TBLS 8
+#else
+#  define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+                                         unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local volatile int crc_table_empty = 1;
+local unsigned long FAR crc_table[TBLS][256];
+local void make_crc_table OF((void));
+#ifdef MAKECRCH
+   local void write_table OF((FILE *, const unsigned long FAR *));
+#endif /* MAKECRCH */
+/*
+  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+  Polynomials over GF(2) are represented in binary, one bit per coefficient,
+  with the lowest powers in the most significant bit.  Then adding polynomials
+  is just exclusive-or, and multiplying a polynomial by x is a right shift by
+  one.  If we call the above polynomial p, and represent a byte as the
+  polynomial q, also with the lowest power in the most significant bit (so the
+  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+  where a mod b means the remainder after dividing a by b.
+
+  This calculation is done using the shift-register method of multiplying and
+  taking the remainder.  The register is initialized to zero, and for each
+  incoming bit, x^32 is added mod p to the register if the bit is a one (where
+  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+  x (which is shifting right by one and adding x^32 mod p if the bit shifted
+  out is a one).  We start with the highest power (least significant bit) of
+  q and repeat for all eight bits of q.
+
+  The first table is simply the CRC of all possible eight bit values.  This is
+  all the information needed to generate CRCs on data a byte at a time for all
+  combinations of CRC register values and incoming bytes.  The remaining tables
+  allow for word-at-a-time CRC calculation for both big-endian and little-
+  endian machines, where a word is four bytes.
+*/
+local void make_crc_table()
+{
+    unsigned long c;
+    int n, k;
+    unsigned long poly;                 /* polynomial exclusive-or pattern */
+    /* terms of polynomial defining this crc (except x^32): */
+    static volatile int first = 1;      /* flag to limit concurrent making */
+    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+    /* See if another task is already doing this (not thread-safe, but better
+       than nothing -- significantly reduces duration of vulnerability in
+       case the advice about DYNAMIC_CRC_TABLE is ignored) */
+    if (first) {
+        first = 0;
+
+        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
+        poly = 0UL;
+        for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++)
+            poly |= 1UL << (31 - p[n]);
+
+        /* generate a crc for every 8-bit value */
+        for (n = 0; n < 256; n++) {
+            c = (unsigned long)n;
+            for (k = 0; k < 8; k++)
+                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+            crc_table[0][n] = c;
+        }
+
+#ifdef BYFOUR
+        /* generate crc for each value followed by one, two, and three zeros,
+           and then the byte reversal of those as well as the first table */
+        for (n = 0; n < 256; n++) {
+            c = crc_table[0][n];
+            crc_table[4][n] = REV(c);
+            for (k = 1; k < 4; k++) {
+                c = crc_table[0][c & 0xff] ^ (c >> 8);
+                crc_table[k][n] = c;
+                crc_table[k + 4][n] = REV(c);
+            }
+        }
+#endif /* BYFOUR */
+
+        crc_table_empty = 0;
+    }
+    else {      /* not first */
+        /* wait for the other guy to finish (not efficient, but rare) */
+        while (crc_table_empty)
+            ;
+    }
+
+#ifdef MAKECRCH
+    /* write out CRC tables to crc32.h */
+    {
+        FILE *out;
+
+        out = fopen("crc32.h", "w");
+        if (out == NULL) return;
+        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
+        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
+        fprintf(out, "local const unsigned long FAR ");
+        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
+        write_table(out, crc_table[0]);
+#  ifdef BYFOUR
+        fprintf(out, "#ifdef BYFOUR\n");
+        for (k = 1; k < 8; k++) {
+            fprintf(out, "  },\n  {\n");
+            write_table(out, crc_table[k]);
+        }
+        fprintf(out, "#endif\n");
+#  endif /* BYFOUR */
+        fprintf(out, "  }\n};\n");
+        fclose(out);
+    }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+local void write_table(out, table)
+    FILE *out;
+    const unsigned long FAR *table;
+{
+    int n;
+
+    for (n = 0; n < 256; n++)
+        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ", table[n],
+                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
+}
+#endif /* MAKECRCH */
+
+#else /* !DYNAMIC_CRC_TABLE */
+/* ========================================================================
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
+ */
+#include "crc32.h"
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const unsigned long FAR * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+    return (const unsigned long FAR *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+    if (sizeof(void *) == sizeof(ptrdiff_t)) {
+        u4 endian;
+
+        endian = 1;
+        if (*((unsigned char *)(&endian)))
+            return crc32_little(crc, buf, len);
+        else
+            return crc32_big(crc, buf, len);
+    }
+#endif /* BYFOUR */
+    crc = crc ^ 0xffffffffUL;
+    while (len >= 8) {
+        DO8;
+        len -= 8;
+    }
+    if (len) do {
+        DO1;
+    } while (--len);
+    return crc ^ 0xffffffffUL;
+}
+
+#ifdef BYFOUR
+
+/* ========================================================================= */
+#define DOLIT4 c ^= *buf4++; \
+        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
+            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+
+/* ========================================================================= */
+local unsigned long crc32_little(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    register u4 c;
+    register const u4 FAR *buf4;
+
+    c = (u4)crc;
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+        len--;
+    }
+
+    buf4 = (const u4 FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOLIT32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOLIT4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)c;
+}
+
+/* ========================================================================= */
+#define DOBIG4 c ^= *++buf4; \
+        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
+            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+
+/* ========================================================================= */
+local unsigned long crc32_big(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    unsigned len;
+{
+    register u4 c;
+    register const u4 FAR *buf4;
+
+    c = REV((u4)crc);
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+        len--;
+    }
+
+    buf4 = (const u4 FAR *)(const void FAR *)buf;
+    buf4--;
+    while (len >= 32) {
+        DOBIG32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOBIG4;
+        len -= 4;
+    }
+    buf4++;
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)(REV(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+    unsigned long *mat;
+    unsigned long vec;
+{
+    unsigned long sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+    unsigned long *square;
+    unsigned long *mat;
+{
+    int n;
+
+    for (n = 0; n < GF2_DIM; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off_t len2;
+{
+    int n;
+    unsigned long row;
+    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
+    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
+
+    /* degenerate case */
+    if (len2 == 0)
+        return crc1;
+
+    /* put operator for one zero bit in odd */
+    odd[0] = 0xedb88320L;           /* CRC-32 polynomial */
+    row = 1;
+    for (n = 1; n < GF2_DIM; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* put operator for two zero bits in even */
+    gf2_matrix_square(even, odd);
+
+    /* put operator for four zero bits in odd */
+    gf2_matrix_square(odd, even);
+
+    /* apply len2 zeros to crc1 (first square will put the operator for one
+       zero byte, eight zero bits, in even) */
+    do {
+        /* apply zeros operator for this bit of len2 */
+        gf2_matrix_square(even, odd);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(even, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+        if (len2 == 0)
+            break;
+
+        /* another iteration of the loop with odd and even swapped */
+        gf2_matrix_square(odd, even);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(odd, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+    } while (len2 != 0);
+
+    /* return combined crc */
+    crc1 ^= crc2;
+    return crc1;
+}

contrib/zlib/crc32.h

@@ -0,0 +1,441 @@
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const unsigned long FAR crc_table[TBLS][256] =
+{
+  {
+    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+    0x2d02ef8dUL
+#ifdef BYFOUR
+  },
+  {
+    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+    0x9324fd72UL
+  },
+  {
+    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+    0xbe9834edUL
+  },
+  {
+    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+    0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+    0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+    0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+    0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+    0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+    0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+    0xde0506f1UL
+  },
+  {
+    0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+    0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+    0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+    0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+    0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+    0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+    0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+    0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+    0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+    0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+    0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+    0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+    0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+    0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+    0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+    0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+    0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+    0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+    0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+    0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+    0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+    0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+    0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+    0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+    0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+    0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+    0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+    0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+    0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+    0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+    0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+    0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+    0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+    0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+    0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+    0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+    0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+    0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+    0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+    0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+    0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+    0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+    0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+    0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+    0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+    0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+    0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+    0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+    0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+    0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+    0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+    0x8def022dUL
+  },
+  {
+    0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+    0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+    0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+    0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+    0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+    0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+    0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+    0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+    0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+    0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+    0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+    0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+    0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+    0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+    0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+    0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+    0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+    0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+    0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+    0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+    0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+    0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+    0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+    0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+    0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+    0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+    0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+    0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+    0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+    0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+    0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+    0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+    0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+    0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+    0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+    0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+    0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+    0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+    0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+    0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+    0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+    0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+    0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+    0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+    0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+    0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+    0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+    0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+    0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+    0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+    0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+    0x72fd2493UL
+  },
+  {
+    0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+    0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+    0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+    0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+    0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+    0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+    0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+    0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+    0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+    0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+    0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+    0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+    0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+    0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+    0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+    0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+    0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+    0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+    0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+    0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+    0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+    0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+    0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+    0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+    0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+    0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+    0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+    0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+    0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+    0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+    0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+    0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+    0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+    0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+    0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+    0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+    0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+    0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+    0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+    0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+    0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+    0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+    0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+    0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+    0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+    0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+    0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+    0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+    0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+    0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+    0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+    0xed3498beUL
+  },
+  {
+    0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+    0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+    0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+    0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+    0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+    0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+    0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+    0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+    0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+    0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+    0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+    0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+    0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+    0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+    0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+    0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+    0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+    0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+    0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+    0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+    0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+    0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+    0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+    0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+    0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+    0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+    0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+    0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+    0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+    0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+    0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+    0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+    0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+    0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+    0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+    0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+    0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+    0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+    0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+    0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+    0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+    0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+    0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+    0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+    0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+    0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+    0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+    0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+    0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+    0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+    0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+    0xf10605deUL
+#endif
+  }
+};

contrib/zlib/inffast.c

@@ -0,0 +1,318 @@
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifndef ASMINF
+
+/* Allow machine dependent optimization for post-increment or pre-increment.
+   Based on testing to date,
+   Pre-increment preferred for:
+   - PowerPC G3 (Adler)
+   - MIPS R5000 (Randers-Pehrson)
+   Post-increment preferred for:
+   - none
+   No measurable difference:
+   - Pentium III (Anderson)
+   - M68060 (Nikl)
+ */
+#ifdef POSTINC
+#  define OFF 0
+#  define PUP(a) *(a)++
+#else
+#  define OFF 1
+#  define PUP(a) *++(a)
+#endif
+
+/*
+   Decode literal, length, and distance codes and write out the resulting
+   literal and match bytes until either not enough input or output is
+   available, an end-of-block is encountered, or a data error is encountered.
+   When large enough input and output buffers are supplied to inflate(), for
+   example, a 16K input buffer and a 64K output buffer, more than 95% of the
+   inflate execution time is spent in this routine.
+
+   Entry assumptions:
+
+        state->mode == LEN
+        strm->avail_in >= 6
+        strm->avail_out >= 258
+        start >= strm->avail_out
+        state->bits < 8
+
+   On return, state->mode is one of:
+
+        LEN -- ran out of enough output space or enough available input
+        TYPE -- reached end of block code, inflate() to interpret next block
+        BAD -- error in block data
+
+   Notes:
+
+    - The maximum input bits used by a length/distance pair is 15 bits for the
+      length code, 5 bits for the length extra, 15 bits for the distance code,
+      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
+      Therefore if strm->avail_in >= 6, then there is enough input to avoid
+      checking for available input while decoding.
+
+    - The maximum bytes that a single length/distance pair can output is 258
+      bytes, which is the maximum length that can be coded.  inflate_fast()
+      requires strm->avail_out >= 258 for each loop to avoid checking for
+      output space.
+ */
+void inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    unsigned char FAR *in;      /* local strm->next_in */
+    unsigned char FAR *last;    /* while in < last, enough input available */
+    unsigned char FAR *out;     /* local strm->next_out */
+    unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
+    unsigned char FAR *end;     /* while out < end, enough space available */
+#ifdef INFLATE_STRICT
+    unsigned dmax;              /* maximum distance from zlib header */
+#endif
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned write;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
+    unsigned long hold;         /* local strm->hold */
+    unsigned bits;              /* local strm->bits */
+    code const FAR *lcode;      /* local strm->lencode */
+    code const FAR *dcode;      /* local strm->distcode */
+    unsigned lmask;             /* mask for first level of length codes */
+    unsigned dmask;             /* mask for first level of distance codes */
+    code this;                  /* retrieved table entry */
+    unsigned op;                /* code bits, operation, extra bits, or */
+                                /*  window position, window bytes to copy */
+    unsigned len;               /* match length, unused bytes */
+    unsigned dist;              /* match distance */
+    unsigned char FAR *from;    /* where to copy match from */
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+    in = strm->next_in - OFF;
+    last = in + (strm->avail_in - 5);
+    out = strm->next_out - OFF;
+    beg = out - (start - strm->avail_out);
+    end = out + (strm->avail_out - 257);
+#ifdef INFLATE_STRICT
+    dmax = state->dmax;
+#endif
+    wsize = state->wsize;
+    whave = state->whave;
+    write = state->write;
+    window = state->window;
+    hold = state->hold;
+    bits = state->bits;
+    lcode = state->lencode;
+    dcode = state->distcode;
+    lmask = (1U << state->lenbits) - 1;
+    dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+    do {
+        if (bits < 15) {
+            hold += (unsigned long)(PUP(in)) << bits;
+            bits += 8;
+            hold += (unsigned long)(PUP(in)) << bits;
+            bits += 8;
+        }
+        this = lcode[hold & lmask];
+      dolen:
+        op = (unsigned)(this.bits);
+        hold >>= op;
+        bits -= op;
+        op = (unsigned)(this.op);
+        if (op == 0) {                          /* literal */
+            Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+                    "inflate:         literal '%c'\n" :
+                    "inflate:         literal 0x%02x\n", this.val));
+            PUP(out) = (unsigned char)(this.val);
+        }
+        else if (op & 16) {                     /* length base */
+            len = (unsigned)(this.val);
+            op &= 15;                           /* number of extra bits */
+            if (op) {
+                if (bits < op) {
+                    hold += (unsigned long)(PUP(in)) << bits;
+                    bits += 8;
+                }
+                len += (unsigned)hold & ((1U << op) - 1);
+                hold >>= op;
+                bits -= op;
+            }
+            Tracevv((stderr, "inflate:         length %u\n", len));
+            if (bits < 15) {
+                hold += (unsigned long)(PUP(in)) << bits;
+                bits += 8;
+                hold += (unsigned long)(PUP(in)) << bits;
+                bits += 8;
+            }
+            this = dcode[hold & dmask];
+          dodist:
+            op = (unsigned)(this.bits);
+            hold >>= op;
+            bits -= op;
+            op = (unsigned)(this.op);
+            if (op & 16) {                      /* distance base */
+                dist = (unsigned)(this.val);
+                op &= 15;                       /* number of extra bits */
+                if (bits < op) {
+                    hold += (unsigned long)(PUP(in)) << bits;
+                    bits += 8;
+                    if (bits < op) {
+                        hold += (unsigned long)(PUP(in)) << bits;
+                        bits += 8;
+                    }
+                }
+                dist += (unsigned)hold & ((1U << op) - 1);
+#ifdef INFLATE_STRICT
+                if (dist > dmax) {
+                    strm->msg = (char *)"invalid distance too far back";
+                    state->mode = BAD;
+                    break;
+                }
+#endif
+                hold >>= op;
+                bits -= op;
+                Tracevv((stderr, "inflate:         distance %u\n", dist));
+                op = (unsigned)(out - beg);     /* max distance in output */
+                if (dist > op) {                /* see if copy from window */
+                    op = dist - op;             /* distance back in window */
+                    if (op > whave) {
+                        strm->msg = (char *)"invalid distance too far back";
+                        state->mode = BAD;
+                        break;
+                    }
+                    from = window - OFF;
+                    if (write == 0) {           /* very common case */
+                        from += wsize - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                PUP(out) = PUP(from);
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    else if (write < op) {      /* wrap around window */
+                        from += wsize + write - op;
+                        op -= write;
+                        if (op < len) {         /* some from end of window */
+                            len -= op;
+                            do {
+                                PUP(out) = PUP(from);
+                            } while (--op);
+                            from = window - OFF;
+                            if (write < len) {  /* some from start of window */
+                                op = write;
+                                len -= op;
+                                do {
+                                    PUP(out) = PUP(from);
+                                } while (--op);
+                                from = out - dist;      /* rest from output */
+                            }
+                        }
+                    }
+                    else {                      /* contiguous in window */
+                        from += write - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                PUP(out) = PUP(from);
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    while (len > 2) {
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        len -= 3;
+                    }
+                    if (len) {
+                        PUP(out) = PUP(from);
+                        if (len > 1)
+                            PUP(out) = PUP(from);
+                    }
+                }
+                else {
+                    from = out - dist;          /* copy direct from output */
+                    do {                        /* minimum length is three */
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        PUP(out) = PUP(from);
+                        len -= 3;
+                    } while (len > 2);
+                    if (len) {
+                        PUP(out) = PUP(from);
+                        if (len > 1)
+                            PUP(out) = PUP(from);
+                    }
+                }
+            }
+            else if ((op & 64) == 0) {          /* 2nd level distance code */
+                this = dcode[this.val + (hold & ((1U << op) - 1))];
+                goto dodist;
+            }
+            else {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+        }
+        else if ((op & 64) == 0) {              /* 2nd level length code */
+            this = lcode[this.val + (hold & ((1U << op) - 1))];
+            goto dolen;
+        }
+        else if (op & 32) {                     /* end-of-block */
+            Tracevv((stderr, "inflate:         end of block\n"));
+            state->mode = TYPE;
+            break;
+        }
+        else {
+            strm->msg = (char *)"invalid literal/length code";
+            state->mode = BAD;
+            break;
+        }
+    } while (in < last && out < end);
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    len = bits >> 3;
+    in -= len;
+    bits -= len << 3;
+    hold &= (1U << bits) - 1;
+
+    /* update state and return */
+    strm->next_in = in + OFF;
+    strm->next_out = out + OFF;
+    strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
+    strm->avail_out = (unsigned)(out < end ?
+                                 257 + (end - out) : 257 - (out - end));
+    state->hold = hold;
+    state->bits = bits;
+    return;
+}
+
+/*
+   inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
+   - Using bit fields for code structure
+   - Different op definition to avoid & for extra bits (do & for table bits)
+   - Three separate decoding do-loops for direct, window, and write == 0
+   - Special case for distance > 1 copies to do overlapped load and store copy
+   - Explicit branch predictions (based on measured branch probabilities)
+   - Deferring match copy and interspersed it with decoding subsequent codes
+   - Swapping literal/length else
+   - Swapping window/direct else
+   - Larger unrolled copy loops (three is about right)
+   - Moving len -= 3 statement into middle of loop
+ */
+
+#endif /* !ASMINF */

contrib/zlib/inffast.h

@@ -0,0 +1,11 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+void inflate_fast OF((z_streamp strm, unsigned start));

contrib/zlib/inffixed.h

@@ -0,0 +1,94 @@
+    /* inffixed.h -- table for decoding fixed codes
+     * Generated automatically by makefixed().
+     */
+
+    /* WARNING: this file should *not* be used by applications. It
+       is part of the implementation of the compression library and
+       is subject to change. Applications should only use zlib.h.
+     */
+
+    static const code lenfix[512] = {
+        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+        {0,9,255}
+    };
+
+    static const code distfix[32] = {
+        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+        {22,5,193},{64,5,0}
+    };

contrib/zlib/inflate.c

@@ -0,0 +1,1368 @@
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * Change history:
+ *
+ * 1.2.beta0    24 Nov 2002
+ * - First version -- complete rewrite of inflate to simplify code, avoid
+ *   creation of window when not needed, minimize use of window when it is
+ *   needed, make inffast.c even faster, implement gzip decoding, and to
+ *   improve code readability and style over the previous zlib inflate code
+ *
+ * 1.2.beta1    25 Nov 2002
+ * - Use pointers for available input and output checking in inffast.c
+ * - Remove input and output counters in inffast.c
+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
+ * - Remove unnecessary second byte pull from length extra in inffast.c
+ * - Unroll direct copy to three copies per loop in inffast.c
+ *
+ * 1.2.beta2    4 Dec 2002
+ * - Change external routine names to reduce potential conflicts
+ * - Correct filename to inffixed.h for fixed tables in inflate.c
+ * - Make hbuf[] unsigned char to match parameter type in inflate.c
+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
+ *   to avoid negation problem on Alphas (64 bit) in inflate.c
+ *
+ * 1.2.beta3    22 Dec 2002
+ * - Add comments on state->bits assertion in inffast.c
+ * - Add comments on op field in inftrees.h
+ * - Fix bug in reuse of allocated window after inflateReset()
+ * - Remove bit fields--back to byte structure for speed
+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
+ * - Use local copies of stream next and avail values, as well as local bit
+ *   buffer and bit count in inflate()--for speed when inflate_fast() not used
+ *
+ * 1.2.beta4    1 Jan 2003
+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
+ * - Move a comment on output buffer sizes from inffast.c to inflate.c
+ * - Add comments in inffast.c to introduce the inflate_fast() routine
+ * - Rearrange window copies in inflate_fast() for speed and simplification
+ * - Unroll last copy for window match in inflate_fast()
+ * - Use local copies of window variables in inflate_fast() for speed
+ * - Pull out common write == 0 case for speed in inflate_fast()
+ * - Make op and len in inflate_fast() unsigned for consistency
+ * - Add FAR to lcode and dcode declarations in inflate_fast()
+ * - Simplified bad distance check in inflate_fast()
+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
+ *   source file infback.c to provide a call-back interface to inflate for
+ *   programs like gzip and unzip -- uses window as output buffer to avoid
+ *   window copying
+ *
+ * 1.2.beta5    1 Jan 2003
+ * - Improved inflateBack() interface to allow the caller to provide initial
+ *   input in strm.
+ * - Fixed stored blocks bug in inflateBack()
+ *
+ * 1.2.beta6    4 Jan 2003
+ * - Added comments in inffast.c on effectiveness of POSTINC
+ * - Typecasting all around to reduce compiler warnings
+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to
+ *   make compilers happy
+ * - Changed type of window in inflateBackInit() to unsigned char *
+ *
+ * 1.2.beta7    27 Jan 2003
+ * - Changed many types to unsigned or unsigned short to avoid warnings
+ * - Added inflateCopy() function
+ *
+ * 1.2.0        9 Mar 2003
+ * - Changed inflateBack() interface to provide separate opaque descriptors
+ *   for the in() and out() functions
+ * - Changed inflateBack() argument and in_func typedef to swap the length
+ *   and buffer address return values for the input function
+ * - Check next_in and next_out for Z_NULL on entry to inflate()
+ *
+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef MAKEFIXED
+#  ifndef BUILDFIXED
+#    define BUILDFIXED
+#  endif
+#endif
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+local int updatewindow OF((z_streamp strm, unsigned out));
+#ifdef BUILDFIXED
+   void makefixed OF((void));
+#endif
+local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf,
+                              unsigned len));
+
+int ZEXPORT inflateReset(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    strm->total_in = strm->total_out = state->total = 0;
+    strm->msg = Z_NULL;
+    strm->adler = 1;        /* to support ill-conceived Java test suite */
+    state->mode = HEAD;
+    state->last = 0;
+    state->havedict = 0;
+    state->dmax = 32768U;
+    state->head = Z_NULL;
+    state->wsize = 0;
+    state->whave = 0;
+    state->write = 0;
+    state->hold = 0;
+    state->bits = 0;
+    state->lencode = state->distcode = state->next = state->codes;
+    Tracev((stderr, "inflate: reset\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflatePrime(strm, bits, value)
+z_streamp strm;
+int bits;
+int value;
+{
+    struct inflate_state FAR *state;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
+    value &= (1L << bits) - 1;
+    state->hold += value << state->bits;
+    state->bits += bits;
+    return Z_OK;
+}
+
+int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+z_streamp strm;
+int windowBits;
+const char *version;
+int stream_size;
+{
+    struct inflate_state FAR *state;
+
+    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+        stream_size != (int)(sizeof(z_stream)))
+        return Z_VERSION_ERROR;
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+    strm->msg = Z_NULL;                 /* in case we return an error */
+    if (strm->zalloc == (alloc_func)0) {
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+    }
+    if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+    state = (struct inflate_state FAR *)
+            ZALLOC(strm, 1, sizeof(struct inflate_state));
+    if (state == Z_NULL) return Z_MEM_ERROR;
+    Tracev((stderr, "inflate: allocated\n"));
+    strm->state = (struct internal_state FAR *)state;
+    if (windowBits < 0) {
+        state->wrap = 0;
+        windowBits = -windowBits;
+    }
+    else {
+        state->wrap = (windowBits >> 4) + 1;
+#ifdef GUNZIP
+        if (windowBits < 48) windowBits &= 15;
+#endif
+    }
+    if (windowBits < 8 || windowBits > 15) {
+        ZFREE(strm, state);
+        strm->state = Z_NULL;
+        return Z_STREAM_ERROR;
+    }
+    state->wbits = (unsigned)windowBits;
+    state->window = Z_NULL;
+    return inflateReset(strm);
+}
+
+int ZEXPORT inflateInit_(strm, version, stream_size)
+z_streamp strm;
+const char *version;
+int stream_size;
+{
+    return inflateInit2_(strm, DEF_WBITS, version, stream_size);
+}
+
+/*
+   Return state with length and distance decoding tables and index sizes set to
+   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
+   If BUILDFIXED is defined, then instead this routine builds the tables the
+   first time it's called, and returns those tables the first time and
+   thereafter.  This reduces the size of the code by about 2K bytes, in
+   exchange for a little execution time.  However, BUILDFIXED should not be
+   used for threaded applications, since the rewriting of the tables and virgin
+   may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+    static int virgin = 1;
+    static code *lenfix, *distfix;
+    static code fixed[544];
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        unsigned sym, bits;
+        static code *next;
+
+        /* literal/length table */
+        sym = 0;
+        while (sym < 144) state->lens[sym++] = 8;
+        while (sym < 256) state->lens[sym++] = 9;
+        while (sym < 280) state->lens[sym++] = 7;
+        while (sym < 288) state->lens[sym++] = 8;
+        next = fixed;
+        lenfix = next;
+        bits = 9;
+        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+        /* distance table */
+        sym = 0;
+        while (sym < 32) state->lens[sym++] = 5;
+        distfix = next;
+        bits = 5;
+        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+        /* do this just once */
+        virgin = 0;
+    }
+#else /* !BUILDFIXED */
+#   include "inffixed.h"
+#endif /* BUILDFIXED */
+    state->lencode = lenfix;
+    state->lenbits = 9;
+    state->distcode = distfix;
+    state->distbits = 5;
+}
+
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+/*
+   Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
+   defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
+   those tables to stdout, which would be piped to inffixed.h.  A small program
+   can simply call makefixed to do this:
+
+    void makefixed(void);
+
+    int main(void)
+    {
+        makefixed();
+        return 0;
+    }
+
+   Then that can be linked with zlib built with MAKEFIXED defined and run:
+
+    a.out > inffixed.h
+ */
+void makefixed()
+{
+    unsigned low, size;
+    struct inflate_state state;
+
+    fixedtables(&state);
+    puts("    /* inffixed.h -- table for decoding fixed codes");
+    puts("     * Generated automatically by makefixed().");
+    puts("     */");
+    puts("");
+    puts("    /* WARNING: this file should *not* be used by applications.");
+    puts("       It is part of the implementation of this library and is");
+    puts("       subject to change. Applications should only use zlib.h.");
+    puts("     */");
+    puts("");
+    size = 1U << 9;
+    printf("    static const code lenfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 7) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits,
+               state.lencode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+    size = 1U << 5;
+    printf("\n    static const code distfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 6) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
+               state.distcode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+}
+#endif /* MAKEFIXED */
+
+/*
+   Update the window with the last wsize (normally 32K) bytes written before
+   returning.  If window does not exist yet, create it.  This is only called
+   when a window is already in use, or when output has been written during this
+   inflate call, but the end of the deflate stream has not been reached yet.
+   It is also called to create a window for dictionary data when a dictionary
+   is loaded.
+
+   Providing output buffers larger than 32K to inflate() should provide a speed
+   advantage, since only the last 32K of output is copied to the sliding window
+   upon return from inflate(), and since all distances after the first 32K of
+   output will fall in the output data, making match copies simpler and faster.
+   The advantage may be dependent on the size of the processor's data caches.
+ */
+local int updatewindow(strm, out)
+z_streamp strm;
+unsigned out;
+{
+    struct inflate_state FAR *state;
+    unsigned copy, dist;
+
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* if it hasn't been done already, allocate space for the window */
+    if (state->window == Z_NULL) {
+        state->window = (unsigned char FAR *)
+                        ZALLOC(strm, 1U << state->wbits,
+                               sizeof(unsigned char));
+        if (state->window == Z_NULL) return 1;
+    }
+
+    /* if window not in use yet, initialize */
+    if (state->wsize == 0) {
+        state->wsize = 1U << state->wbits;
+        state->write = 0;
+        state->whave = 0;
+    }
+
+    /* copy state->wsize or less output bytes into the circular window */
+    copy = out - strm->avail_out;
+    if (copy >= state->wsize) {
+        zmemcpy(state->window, strm->next_out - state->wsize, state->wsize);
+        state->write = 0;
+        state->whave = state->wsize;
+    }
+    else {
+        dist = state->wsize - state->write;
+        if (dist > copy) dist = copy;
+        zmemcpy(state->window + state->write, strm->next_out - copy, dist);
+        copy -= dist;
+        if (copy) {
+            zmemcpy(state->window, strm->next_out - copy, copy);
+            state->write = copy;
+            state->whave = state->wsize;
+        }
+        else {
+            state->write += dist;
+            if (state->write == state->wsize) state->write = 0;
+            if (state->whave < state->wsize) state->whave += dist;
+        }
+    }
+    return 0;
+}
+
+/* Macros for inflate(): */
+
+/* check function to use adler32() for zlib or crc32() for gzip */
+#ifdef GUNZIP
+#  define UPDATE(check, buf, len) \
+    (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
+#else
+#  define UPDATE(check, buf, len) adler32(check, buf, len)
+#endif
+
+/* check macros for header crc */
+#ifdef GUNZIP
+#  define CRC2(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        check = crc32(check, hbuf, 2); \
+    } while (0)
+
+#  define CRC4(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        hbuf[2] = (unsigned char)((word) >> 16); \
+        hbuf[3] = (unsigned char)((word) >> 24); \
+        check = crc32(check, hbuf, 4); \
+    } while (0)
+#endif
+
+/* Load registers with state in inflate() for speed */
+#define LOAD() \
+    do { \
+        put = strm->next_out; \
+        left = strm->avail_out; \
+        next = strm->next_in; \
+        have = strm->avail_in; \
+        hold = state->hold; \
+        bits = state->bits; \
+    } while (0)
+
+/* Restore state from registers in inflate() */
+#define RESTORE() \
+    do { \
+        strm->next_out = put; \
+        strm->avail_out = left; \
+        strm->next_in = next; \
+        strm->avail_in = have; \
+        state->hold = hold; \
+        state->bits = bits; \
+    } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+    do { \
+        hold = 0; \
+        bits = 0; \
+    } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflate()
+   if there is no input available. */
+#define PULLBYTE() \
+    do { \
+        if (have == 0) goto inf_leave; \
+        have--; \
+        hold += (unsigned long)(*next++) << bits; \
+        bits += 8; \
+    } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator.  If there is
+   not enough available input to do that, then return from inflate(). */
+#define NEEDBITS(n) \
+    do { \
+        while (bits < (unsigned)(n)) \
+            PULLBYTE(); \
+    } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+    ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+    do { \
+        hold >>= (n); \
+        bits -= (unsigned)(n); \
+    } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+    do { \
+        hold >>= bits & 7; \
+        bits -= bits & 7; \
+    } while (0)
+
+/* Reverse the bytes in a 32-bit value */
+#define REVERSE(q) \
+    ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+     (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+/*
+   inflate() uses a state machine to process as much input data and generate as
+   much output data as possible before returning.  The state machine is
+   structured roughly as follows:
+
+    for (;;) switch (state) {
+    ...
+    case STATEn:
+        if (not enough input data or output space to make progress)
+            return;
+        ... make progress ...
+        state = STATEm;
+        break;
+    ...
+    }
+
+   so when inflate() is called again, the same case is attempted again, and
+   if the appropriate resources are provided, the machine proceeds to the
+   next state.  The NEEDBITS() macro is usually the way the state evaluates
+   whether it can proceed or should return.  NEEDBITS() does the return if
+   the requested bits are not available.  The typical use of the BITS macros
+   is:
+
+        NEEDBITS(n);
+        ... do something with BITS(n) ...
+        DROPBITS(n);
+
+   where NEEDBITS(n) either returns from inflate() if there isn't enough
+   input left to load n bits into the accumulator, or it continues.  BITS(n)
+   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
+   the low n bits off the accumulator.  INITBITS() clears the accumulator
+   and sets the number of available bits to zero.  BYTEBITS() discards just
+   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
+   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
+
+   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
+   if there is no input available.  The decoding of variable length codes uses
+   PULLBYTE() directly in order to pull just enough bytes to decode the next
+   code, and no more.
+
+   Some states loop until they get enough input, making sure that enough
+   state information is maintained to continue the loop where it left off
+   if NEEDBITS() returns in the loop.  For example, want, need, and keep
+   would all have to actually be part of the saved state in case NEEDBITS()
+   returns:
+
+    case STATEw:
+        while (want < need) {
+            NEEDBITS(n);
+            keep[want++] = BITS(n);
+            DROPBITS(n);
+        }
+        state = STATEx;
+    case STATEx:
+
+   As shown above, if the next state is also the next case, then the break
+   is omitted.
+
+   A state may also return if there is not enough output space available to
+   complete that state.  Those states are copying stored data, writing a
+   literal byte, and copying a matching string.
+
+   When returning, a "goto inf_leave" is used to update the total counters,
+   update the check value, and determine whether any progress has been made
+   during that inflate() call in order to return the proper return code.
+   Progress is defined as a change in either strm->avail_in or strm->avail_out.
+   When there is a window, goto inf_leave will update the window with the last
+   output written.  If a goto inf_leave occurs in the middle of decompression
+   and there is no window currently, goto inf_leave will create one and copy
+   output to the window for the next call of inflate().
+
+   In this implementation, the flush parameter of inflate() only affects the
+   return code (per zlib.h).  inflate() always writes as much as possible to
+   strm->next_out, given the space available and the provided input--the effect
+   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
+   the allocation of and copying into a sliding window until necessary, which
+   provides the effect documented in zlib.h for Z_FINISH when the entire input
+   stream available.  So the only thing the flush parameter actually does is:
+   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
+   will return Z_BUF_ERROR if it has not reached the end of the stream.
+ */
+
+int ZEXPORT inflate(strm, flush)
+z_streamp strm;
+int flush;
+{
+    struct inflate_state FAR *state;
+    unsigned char FAR *next;    /* next input */
+    unsigned char FAR *put;     /* next output */
+    unsigned have, left;        /* available input and output */
+    unsigned long hold;         /* bit buffer */
+    unsigned bits;              /* bits in bit buffer */
+    unsigned in, out;           /* save starting available input and output */
+    unsigned copy;              /* number of stored or match bytes to copy */
+    unsigned char FAR *from;    /* where to copy match bytes from */
+    code this;                  /* current decoding table entry */
+    code last;                  /* parent table entry */
+    unsigned len;               /* length to copy for repeats, bits to drop */
+    int ret;                    /* return code */
+#ifdef GUNZIP
+    unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
+#endif
+    static const unsigned short order[19] = /* permutation of code lengths */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL ||
+        (strm->next_in == Z_NULL && strm->avail_in != 0))
+        return Z_STREAM_ERROR;
+
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
+    LOAD();
+    in = have;
+    out = left;
+    ret = Z_OK;
+    for (;;)
+        switch (state->mode) {
+        case HEAD:
+            if (state->wrap == 0) {
+                state->mode = TYPEDO;
+                break;
+            }
+            NEEDBITS(16);
+#ifdef GUNZIP
+            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
+                state->check = crc32(0L, Z_NULL, 0);
+                CRC2(state->check, hold);
+                INITBITS();
+                state->mode = FLAGS;
+                break;
+            }
+            state->flags = 0;           /* expect zlib header */
+            if (state->head != Z_NULL)
+                state->head->done = -1;
+            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
+#else
+            if (
+#endif
+                ((BITS(8) << 8) + (hold >> 8)) % 31) {
+                strm->msg = (char *)"incorrect header check";
+                state->mode = BAD;
+                break;
+            }
+            if (BITS(4) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            DROPBITS(4);
+            len = BITS(4) + 8;
+            if (len > state->wbits) {
+                strm->msg = (char *)"invalid window size";
+                state->mode = BAD;
+                break;
+            }
+            state->dmax = 1U << len;
+            Tracev((stderr, "inflate:   zlib header ok\n"));
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = hold & 0x200 ? DICTID : TYPE;
+            INITBITS();
+            break;
+#ifdef GUNZIP
+        case FLAGS:
+            NEEDBITS(16);
+            state->flags = (int)(hold);
+            if ((state->flags & 0xff) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            if (state->flags & 0xe000) {
+                strm->msg = (char *)"unknown header flags set";
+                state->mode = BAD;
+                break;
+            }
+            if (state->head != Z_NULL)
+                state->head->text = (int)((hold >> 8) & 1);
+            if (state->flags & 0x0200) CRC2(state->check, hold);
+            INITBITS();
+            state->mode = TIME;
+        case TIME:
+            NEEDBITS(32);
+            if (state->head != Z_NULL)
+                state->head->time = hold;
+            if (state->flags & 0x0200) CRC4(state->check, hold);
+            INITBITS();
+            state->mode = OS;
+        case OS:
+            NEEDBITS(16);
+            if (state->head != Z_NULL) {
+                state->head->xflags = (int)(hold & 0xff);
+                state->head->os = (int)(hold >> 8);
+            }
+            if (state->flags & 0x0200) CRC2(state->check, hold);
+            INITBITS();
+            state->mode = EXLEN;
+        case EXLEN:
+            if (state->flags & 0x0400) {
+                NEEDBITS(16);
+                state->length = (unsigned)(hold);
+                if (state->head != Z_NULL)
+                    state->head->extra_len = (unsigned)hold;
+                if (state->flags & 0x0200) CRC2(state->check, hold);
+                INITBITS();
+            }
+            else if (state->head != Z_NULL)
+                state->head->extra = Z_NULL;
+            state->mode = EXTRA;
+        case EXTRA:
+            if (state->flags & 0x0400) {
+                copy = state->length;
+                if (copy > have) copy = have;
+                if (copy) {
+                    if (state->head != Z_NULL &&
+                        state->head->extra != Z_NULL) {
+                        len = state->head->extra_len - state->length;
+                        zmemcpy(state->head->extra + len, next,
+                                len + copy > state->head->extra_max ?
+                                state->head->extra_max - len : copy);
+                    }
+                    if (state->flags & 0x0200)
+                        state->check = crc32(state->check, next, copy);
+                    have -= copy;
+                    next += copy;
+                    state->length -= copy;
+                }
+                if (state->length) goto inf_leave;
+            }
+            state->length = 0;
+            state->mode = NAME;
+        case NAME:
+            if (state->flags & 0x0800) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->name != Z_NULL &&
+                            state->length < state->head->name_max)
+                        state->head->name[state->length++] = len;
+                } while (len && copy < have);
+                if (state->flags & 0x0200)
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->name = Z_NULL;
+            state->length = 0;
+            state->mode = COMMENT;
+        case COMMENT:
+            if (state->flags & 0x1000) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->comment != Z_NULL &&
+                            state->length < state->head->comm_max)
+                        state->head->comment[state->length++] = len;
+                } while (len && copy < have);
+                if (state->flags & 0x0200)
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->comment = Z_NULL;
+            state->mode = HCRC;
+        case HCRC:
+            if (state->flags & 0x0200) {
+                NEEDBITS(16);
+                if (hold != (state->check & 0xffff)) {
+                    strm->msg = (char *)"header crc mismatch";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+            }
+            if (state->head != Z_NULL) {
+                state->head->hcrc = (int)((state->flags >> 9) & 1);
+                state->head->done = 1;
+            }
+            strm->adler = state->check = crc32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+            break;
+#endif
+        case DICTID:
+            NEEDBITS(32);
+            strm->adler = state->check = REVERSE(hold);
+            INITBITS();
+            state->mode = DICT;
+        case DICT:
+            if (state->havedict == 0) {
+                RESTORE();
+                return Z_NEED_DICT;
+            }
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+        case TYPE:
+            if (flush == Z_BLOCK) goto inf_leave;
+        case TYPEDO:
+            if (state->last) {
+                BYTEBITS();
+                state->mode = CHECK;
+                break;
+            }
+            NEEDBITS(3);
+            state->last = BITS(1);
+            DROPBITS(1);
+            switch (BITS(2)) {
+            case 0:                             /* stored block */
+                Tracev((stderr, "inflate:     stored block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = STORED;
+                break;
+            case 1:                             /* fixed block */
+                fixedtables(state);
+                Tracev((stderr, "inflate:     fixed codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = LEN;              /* decode codes */
+                break;
+            case 2:                             /* dynamic block */
+                Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = TABLE;
+                break;
+            case 3:
+                strm->msg = (char *)"invalid block type";
+                state->mode = BAD;
+            }
+            DROPBITS(2);
+            break;
+        case STORED:
+            BYTEBITS();                         /* go to byte boundary */
+            NEEDBITS(32);
+            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+                strm->msg = (char *)"invalid stored block lengths";
+                state->mode = BAD;
+                break;
+            }
+            state->length = (unsigned)hold & 0xffff;
+            Tracev((stderr, "inflate:       stored length %u\n",
+                    state->length));
+            INITBITS();
+            state->mode = COPY;
+        case COPY:
+            copy = state->length;
+            if (copy) {
+                if (copy > have) copy = have;
+                if (copy > left) copy = left;
+                if (copy == 0) goto inf_leave;
+                zmemcpy(put, next, copy);
+                have -= copy;
+                next += copy;
+                left -= copy;
+                put += copy;
+                state->length -= copy;
+                break;
+            }
+            Tracev((stderr, "inflate:       stored end\n"));
+            state->mode = TYPE;
+            break;
+        case TABLE:
+            NEEDBITS(14);
+            state->nlen = BITS(5) + 257;
+            DROPBITS(5);
+            state->ndist = BITS(5) + 1;
+            DROPBITS(5);
+            state->ncode = BITS(4) + 4;
+            DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+            if (state->nlen > 286 || state->ndist > 30) {
+                strm->msg = (char *)"too many length or distance symbols";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracev((stderr, "inflate:       table sizes ok\n"));
+            state->have = 0;
+            state->mode = LENLENS;
+        case LENLENS:
+            while (state->have < state->ncode) {
+                NEEDBITS(3);
+                state->lens[order[state->have++]] = (unsigned short)BITS(3);
+                DROPBITS(3);
+            }
+            while (state->have < 19)
+                state->lens[order[state->have++]] = 0;
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 7;
+            ret = inflate_table(CODES, state->lens, 19, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid code lengths set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       code lengths ok\n"));
+            state->have = 0;
+            state->mode = CODELENS;
+        case CODELENS:
+            while (state->have < state->nlen + state->ndist) {
+                for (;;) {
+                    this = state->lencode[BITS(state->lenbits)];
+                    if ((unsigned)(this.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                if (this.val < 16) {
+                    NEEDBITS(this.bits);
+                    DROPBITS(this.bits);
+                    state->lens[state->have++] = this.val;
+                }
+                else {
+                    if (this.val == 16) {
+                        NEEDBITS(this.bits + 2);
+                        DROPBITS(this.bits);
+                        if (state->have == 0) {
+                            strm->msg = (char *)"invalid bit length repeat";
+                            state->mode = BAD;
+                            break;
+                        }
+                        len = state->lens[state->have - 1];
+                        copy = 3 + BITS(2);
+                        DROPBITS(2);
+                    }
+                    else if (this.val == 17) {
+                        NEEDBITS(this.bits + 3);
+                        DROPBITS(this.bits);
+                        len = 0;
+                        copy = 3 + BITS(3);
+                        DROPBITS(3);
+                    }
+                    else {
+                        NEEDBITS(this.bits + 7);
+                        DROPBITS(this.bits);
+                        len = 0;
+                        copy = 11 + BITS(7);
+                        DROPBITS(7);
+                    }
+                    if (state->have + copy > state->nlen + state->ndist) {
+                        strm->msg = (char *)"invalid bit length repeat";
+                        state->mode = BAD;
+                        break;
+                    }
+                    while (copy--)
+                        state->lens[state->have++] = (unsigned short)len;
+                }
+            }
+
+            /* handle error breaks in while */
+            if (state->mode == BAD) break;
+
+            /* build code tables */
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 9;
+            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid literal/lengths set";
+                state->mode = BAD;
+                break;
+            }
+            state->distcode = (code const FAR *)(state->next);
+            state->distbits = 6;
+            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+                            &(state->next), &(state->distbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid distances set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       codes ok\n"));
+            state->mode = LEN;
+        case LEN:
+            if (have >= 6 && left >= 258) {
+                RESTORE();
+                inflate_fast(strm, out);
+                LOAD();
+                break;
+            }
+            for (;;) {
+                this = state->lencode[BITS(state->lenbits)];
+                if ((unsigned)(this.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if (this.op && (this.op & 0xf0) == 0) {
+                last = this;
+                for (;;) {
+                    this = state->lencode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + this.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(this.bits);
+            state->length = (unsigned)this.val;
+            if ((int)(this.op) == 0) {
+                Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
+                        "inflate:         literal '%c'\n" :
+                        "inflate:         literal 0x%02x\n", this.val));
+                state->mode = LIT;
+                break;
+            }
+            if (this.op & 32) {
+                Tracevv((stderr, "inflate:         end of block\n"));
+                state->mode = TYPE;
+                break;
+            }
+            if (this.op & 64) {
+                strm->msg = (char *)"invalid literal/length code";
+                state->mode = BAD;
+                break;
+            }
+            state->extra = (unsigned)(this.op) & 15;
+            state->mode = LENEXT;
+        case LENEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->length += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+            Tracevv((stderr, "inflate:         length %u\n", state->length));
+            state->mode = DIST;
+        case DIST:
+            for (;;) {
+                this = state->distcode[BITS(state->distbits)];
+                if ((unsigned)(this.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if ((this.op & 0xf0) == 0) {
+                last = this;
+                for (;;) {
+                    this = state->distcode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + this.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(this.bits);
+            if (this.op & 64) {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+            state->offset = (unsigned)this.val;
+            state->extra = (unsigned)(this.op) & 15;
+            state->mode = DISTEXT;
+        case DISTEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->offset += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+#ifdef INFLATE_STRICT
+            if (state->offset > state->dmax) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            if (state->offset > state->whave + out - left) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+            state->mode = MATCH;
+        case MATCH:
+            if (left == 0) goto inf_leave;
+            copy = out - left;
+            if (state->offset > copy) {         /* copy from window */
+                copy = state->offset - copy;
+                if (copy > state->write) {
+                    copy -= state->write;
+                    from = state->window + (state->wsize - copy);
+                }
+                else
+                    from = state->window + (state->write - copy);
+                if (copy > state->length) copy = state->length;
+            }
+            else {                              /* copy from output */
+                from = put - state->offset;
+                copy = state->length;
+            }
+            if (copy > left) copy = left;
+            left -= copy;
+            state->length -= copy;
+            do {
+                *put++ = *from++;
+            } while (--copy);
+            if (state->length == 0) state->mode = LEN;
+            break;
+        case LIT:
+            if (left == 0) goto inf_leave;
+            *put++ = (unsigned char)(state->length);
+            left--;
+            state->mode = LEN;
+            break;
+        case CHECK:
+            if (state->wrap) {
+                NEEDBITS(32);
+                out -= left;
+                strm->total_out += out;
+                state->total += out;
+                if (out)
+                    strm->adler = state->check =
+                        UPDATE(state->check, put - out, out);
+                out = left;
+                if ((
+#ifdef GUNZIP
+                     state->flags ? hold :
+#endif
+                     REVERSE(hold)) != state->check) {
+                    strm->msg = (char *)"incorrect data check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   check matches trailer\n"));
+            }
+#ifdef GUNZIP
+            state->mode = LENGTH;
+        case LENGTH:
+            if (state->wrap && state->flags) {
+                NEEDBITS(32);
+                if (hold != (state->total & 0xffffffffUL)) {
+                    strm->msg = (char *)"incorrect length check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   length matches trailer\n"));
+            }
+#endif
+            state->mode = DONE;
+        case DONE:
+            ret = Z_STREAM_END;
+            goto inf_leave;
+        case BAD:
+            ret = Z_DATA_ERROR;
+            goto inf_leave;
+        case MEM:
+            return Z_MEM_ERROR;
+        case SYNC:
+        default:
+            return Z_STREAM_ERROR;
+        }
+
+    /*
+       Return from inflate(), updating the total counts and the check value.
+       If there was no progress during the inflate() call, return a buffer
+       error.  Call updatewindow() to create and/or update the window state.
+       Note: a memory error from inflate() is non-recoverable.
+     */
+  inf_leave:
+    RESTORE();
+    if (state->wsize || (state->mode < CHECK && out != strm->avail_out))
+        if (updatewindow(strm, out)) {
+            state->mode = MEM;
+            return Z_MEM_ERROR;
+        }
+    in -= strm->avail_in;
+    out -= strm->avail_out;
+    strm->total_in += in;
+    strm->total_out += out;
+    state->total += out;
+    if (state->wrap && out)
+        strm->adler = state->check =
+            UPDATE(state->check, strm->next_out - out, out);
+    strm->data_type = state->bits + (state->last ? 64 : 0) +
+                      (state->mode == TYPE ? 128 : 0);
+    if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
+        ret = Z_BUF_ERROR;
+    return ret;
+}
+
+int ZEXPORT inflateEnd(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->window != Z_NULL) ZFREE(strm, state->window);
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+    Tracev((stderr, "inflate: end\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+const Bytef *dictionary;
+uInt dictLength;
+{
+    struct inflate_state FAR *state;
+    unsigned long id;
+
+    /* check state */
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->wrap != 0 && state->mode != DICT)
+        return Z_STREAM_ERROR;
+
+    /* check for correct dictionary id */
+    if (state->mode == DICT) {
+        id = adler32(0L, Z_NULL, 0);
+        id = adler32(id, dictionary, dictLength);
+        if (id != state->check)
+            return Z_DATA_ERROR;
+    }
+
+    /* copy dictionary to window */
+    if (updatewindow(strm, strm->avail_out)) {
+        state->mode = MEM;
+        return Z_MEM_ERROR;
+    }
+    if (dictLength > state->wsize) {
+        zmemcpy(state->window, dictionary + dictLength - state->wsize,
+                state->wsize);
+        state->whave = state->wsize;
+    }
+    else {
+        zmemcpy(state->window + state->wsize - dictLength, dictionary,
+                dictLength);
+        state->whave = dictLength;
+    }
+    state->havedict = 1;
+    Tracev((stderr, "inflate:   dictionary set\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateGetHeader(strm, head)
+z_streamp strm;
+gz_headerp head;
+{
+    struct inflate_state FAR *state;
+
+    /* check state */
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
+
+    /* save header structure */
+    state->head = head;
+    head->done = 0;
+    return Z_OK;
+}
+
+/*
+   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
+   or when out of input.  When called, *have is the number of pattern bytes
+   found in order so far, in 0..3.  On return *have is updated to the new
+   state.  If on return *have equals four, then the pattern was found and the
+   return value is how many bytes were read including the last byte of the
+   pattern.  If *have is less than four, then the pattern has not been found
+   yet and the return value is len.  In the latter case, syncsearch() can be
+   called again with more data and the *have state.  *have is initialized to
+   zero for the first call.
+ */
+local unsigned syncsearch(have, buf, len)
+unsigned FAR *have;
+unsigned char FAR *buf;
+unsigned len;
+{
+    unsigned got;
+    unsigned next;
+
+    got = *have;
+    next = 0;
+    while (next < len && got < 4) {
+        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
+            got++;
+        else if (buf[next])
+            got = 0;
+        else
+            got = 4 - got;
+        next++;
+    }
+    *have = got;
+    return next;
+}
+
+int ZEXPORT inflateSync(strm)
+z_streamp strm;
+{
+    unsigned len;               /* number of bytes to look at or looked at */
+    unsigned long in, out;      /* temporary to save total_in and total_out */
+    unsigned char buf[4];       /* to restore bit buffer to byte string */
+    struct inflate_state FAR *state;
+
+    /* check parameters */
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
+
+    /* if first time, start search in bit buffer */
+    if (state->mode != SYNC) {
+        state->mode = SYNC;
+        state->hold <<= state->bits & 7;
+        state->bits -= state->bits & 7;
+        len = 0;
+        while (state->bits >= 8) {
+            buf[len++] = (unsigned char)(state->hold);
+            state->hold >>= 8;
+            state->bits -= 8;
+        }
+        state->have = 0;
+        syncsearch(&(state->have), buf, len);
+    }
+
+    /* search available input */
+    len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
+    strm->avail_in -= len;
+    strm->next_in += len;
+    strm->total_in += len;
+
+    /* return no joy or set up to restart inflate() on a new block */
+    if (state->have != 4) return Z_DATA_ERROR;
+    in = strm->total_in;  out = strm->total_out;
+    inflateReset(strm);
+    strm->total_in = in;  strm->total_out = out;
+    state->mode = TYPE;
+    return Z_OK;
+}
+
+/*
+   Returns true if inflate is currently at the end of a block generated by
+   Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+   implementation to provide an additional safety check. PPP uses
+   Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
+   block. When decompressing, PPP checks that at the end of input packet,
+   inflate is waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    return state->mode == STORED && state->bits == 0;
+}
+
+int ZEXPORT inflateCopy(dest, source)
+z_streamp dest;
+z_streamp source;
+{
+    struct inflate_state FAR *state;
+    struct inflate_state FAR *copy;
+    unsigned char FAR *window;
+    unsigned wsize;
+
+    /* check input */
+    if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
+        source->zalloc == (alloc_func)0 || source->zfree == (free_func)0)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)source->state;
+
+    /* allocate space */
+    copy = (struct inflate_state FAR *)
+           ZALLOC(source, 1, sizeof(struct inflate_state));
+    if (copy == Z_NULL) return Z_MEM_ERROR;
+    window = Z_NULL;
+    if (state->window != Z_NULL) {
+        window = (unsigned char FAR *)
+                 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+        if (window == Z_NULL) {
+            ZFREE(source, copy);
+            return Z_MEM_ERROR;
+        }
+    }
+
+    /* copy state */
+    zmemcpy(dest, source, sizeof(z_stream));
+    zmemcpy(copy, state, sizeof(struct inflate_state));
+    if (state->lencode >= state->codes &&
+        state->lencode <= state->codes + ENOUGH - 1) {
+        copy->lencode = copy->codes + (state->lencode - state->codes);
+        copy->distcode = copy->codes + (state->distcode - state->codes);
+    }
+    copy->next = copy->codes + (state->next - state->codes);
+    if (window != Z_NULL) {
+        wsize = 1U << state->wbits;
+        zmemcpy(window, state->window, wsize);
+    }
+    copy->window = window;
+    dest->state = (struct internal_state FAR *)copy;
+    return Z_OK;
+}

contrib/zlib/inflate.h

@@ -0,0 +1,115 @@
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2004 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip decoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+    HEAD,       /* i: waiting for magic header */
+    FLAGS,      /* i: waiting for method and flags (gzip) */
+    TIME,       /* i: waiting for modification time (gzip) */
+    OS,         /* i: waiting for extra flags and operating system (gzip) */
+    EXLEN,      /* i: waiting for extra length (gzip) */
+    EXTRA,      /* i: waiting for extra bytes (gzip) */
+    NAME,       /* i: waiting for end of file name (gzip) */
+    COMMENT,    /* i: waiting for end of comment (gzip) */
+    HCRC,       /* i: waiting for header crc (gzip) */
+    DICTID,     /* i: waiting for dictionary check value */
+    DICT,       /* waiting for inflateSetDictionary() call */
+        TYPE,       /* i: waiting for type bits, including last-flag bit */
+        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
+        STORED,     /* i: waiting for stored size (length and complement) */
+        COPY,       /* i/o: waiting for input or output to copy stored block */
+        TABLE,      /* i: waiting for dynamic block table lengths */
+        LENLENS,    /* i: waiting for code length code lengths */
+        CODELENS,   /* i: waiting for length/lit and distance code lengths */
+            LEN,        /* i: waiting for length/lit code */
+            LENEXT,     /* i: waiting for length extra bits */
+            DIST,       /* i: waiting for distance code */
+            DISTEXT,    /* i: waiting for distance extra bits */
+            MATCH,      /* o: waiting for output space to copy string */
+            LIT,        /* o: waiting for output space to write literal */
+    CHECK,      /* i: waiting for 32-bit check value */
+    LENGTH,     /* i: waiting for 32-bit length (gzip) */
+    DONE,       /* finished check, done -- remain here until reset */
+    BAD,        /* got a data error -- remain here until reset */
+    MEM,        /* got an inflate() memory error -- remain here until reset */
+    SYNC        /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+    State transitions between above modes -
+
+    (most modes can go to the BAD or MEM mode -- not shown for clarity)
+
+    Process header:
+        HEAD -> (gzip) or (zlib)
+        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME
+        NAME -> COMMENT -> HCRC -> TYPE
+        (zlib) -> DICTID or TYPE
+        DICTID -> DICT -> TYPE
+    Read deflate blocks:
+            TYPE -> STORED or TABLE or LEN or CHECK
+            STORED -> COPY -> TYPE
+            TABLE -> LENLENS -> CODELENS -> LEN
+    Read deflate codes:
+                LEN -> LENEXT or LIT or TYPE
+                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+                LIT -> LEN
+    Process trailer:
+        CHECK -> LENGTH -> DONE
+ */
+
+/* state maintained between inflate() calls.  Approximately 7K bytes. */
+struct inflate_state {
+    inflate_mode mode;          /* current inflate mode */
+    int last;                   /* true if processing last block */
+    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip */
+    int havedict;               /* true if dictionary provided */
+    int flags;                  /* gzip header method and flags (0 if zlib) */
+    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
+    unsigned long check;        /* protected copy of check value */
+    unsigned long total;        /* protected copy of output count */
+    gz_headerp head;            /* where to save gzip header information */
+        /* sliding window */
+    unsigned wbits;             /* log base 2 of requested window size */
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned write;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if needed */
+        /* bit accumulator */
+    unsigned long hold;         /* input bit accumulator */
+    unsigned bits;              /* number of bits in "in" */
+        /* for string and stored block copying */
+    unsigned length;            /* literal or length of data to copy */
+    unsigned offset;            /* distance back to copy string from */
+        /* for table and code decoding */
+    unsigned extra;             /* extra bits needed */
+        /* fixed and dynamic code tables */
+    code const FAR *lencode;    /* starting table for length/literal codes */
+    code const FAR *distcode;   /* starting table for distance codes */
+    unsigned lenbits;           /* index bits for lencode */
+    unsigned distbits;          /* index bits for distcode */
+        /* dynamic table building */
+    unsigned ncode;             /* number of code length code lengths */
+    unsigned nlen;              /* number of length code lengths */
+    unsigned ndist;             /* number of distance code lengths */
+    unsigned have;              /* number of code lengths in lens[] */
+    code FAR *next;             /* next available space in codes[] */
+    unsigned short lens[320];   /* temporary storage for code lengths */
+    unsigned short work[288];   /* work area for code table building */
+    code codes[ENOUGH];         /* space for code tables */
+};

contrib/zlib/inftrees.c

@@ -0,0 +1,329 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#define MAXBITS 15
+
+const char inflate_copyright[] =
+   " inflate 1.2.3 Copyright 1995-2005 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/*
+   Build a set of tables to decode the provided canonical Huffman code.
+   The code lengths are lens[0..codes-1].  The result starts at *table,
+   whose indices are 0..2^bits-1.  work is a writable array of at least
+   lens shorts, which is used as a work area.  type is the type of code
+   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
+   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
+   on return points to the next available entry's address.  bits is the
+   requested root table index bits, and on return it is the actual root
+   table index bits.  It will differ if the request is greater than the
+   longest code or if it is less than the shortest code.
+ */
+int inflate_table(type, lens, codes, table, bits, work)
+codetype type;
+unsigned short FAR *lens;
+unsigned codes;
+code FAR * FAR *table;
+unsigned FAR *bits;
+unsigned short FAR *work;
+{
+    unsigned len;               /* a code's length in bits */
+    unsigned sym;               /* index of code symbols */
+    unsigned min, max;          /* minimum and maximum code lengths */
+    unsigned root;              /* number of index bits for root table */
+    unsigned curr;              /* number of index bits for current table */
+    unsigned drop;              /* code bits to drop for sub-table */
+    int left;                   /* number of prefix codes available */
+    unsigned used;              /* code entries in table used */
+    unsigned huff;              /* Huffman code */
+    unsigned incr;              /* for incrementing code, index */
+    unsigned fill;              /* index for replicating entries */
+    unsigned low;               /* low bits for current root entry */
+    unsigned mask;              /* mask for low root bits */
+    code this;                  /* table entry for duplication */
+    code FAR *next;             /* next available space in table */
+    const unsigned short FAR *base;     /* base value table to use */
+    const unsigned short FAR *extra;    /* extra bits table to use */
+    int end;                    /* use base and extra for symbol > end */
+    unsigned short count[MAXBITS+1];    /* number of codes of each length */
+    unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
+    static const unsigned short lbase[31] = { /* Length codes 257..285 base */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 201, 196};
+    static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577, 0, 0};
+    static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
+        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+        28, 28, 29, 29, 64, 64};
+
+    /*
+       Process a set of code lengths to create a canonical Huffman code.  The
+       code lengths are lens[0..codes-1].  Each length corresponds to the
+       symbols 0..codes-1.  The Huffman code is generated by first sorting the
+       symbols by length from short to long, and retaining the symbol order
+       for codes with equal lengths.  Then the code starts with all zero bits
+       for the first code of the shortest length, and the codes are integer
+       increments for the same length, and zeros are appended as the length
+       increases.  For the deflate format, these bits are stored backwards
+       from their more natural integer increment ordering, and so when the
+       decoding tables are built in the large loop below, the integer codes
+       are incremented backwards.
+
+       This routine assumes, but does not check, that all of the entries in
+       lens[] are in the range 0..MAXBITS.  The caller must assure this.
+       1..MAXBITS is interpreted as that code length.  zero means that that
+       symbol does not occur in this code.
+
+       The codes are sorted by computing a count of codes for each length,
+       creating from that a table of starting indices for each length in the
+       sorted table, and then entering the symbols in order in the sorted
+       table.  The sorted table is work[], with that space being provided by
+       the caller.
+
+       The length counts are used for other purposes as well, i.e. finding
+       the minimum and maximum length codes, determining if there are any
+       codes at all, checking for a valid set of lengths, and looking ahead
+       at length counts to determine sub-table sizes when building the
+       decoding tables.
+     */
+
+    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+    for (len = 0; len <= MAXBITS; len++)
+        count[len] = 0;
+    for (sym = 0; sym < codes; sym++)
+        count[lens[sym]]++;
+
+    /* bound code lengths, force root to be within code lengths */
+    root = *bits;
+    for (max = MAXBITS; max >= 1; max--)
+        if (count[max] != 0) break;
+    if (root > max) root = max;
+    if (max == 0) {                     /* no symbols to code at all */
+        this.op = (unsigned char)64;    /* invalid code marker */
+        this.bits = (unsigned char)1;
+        this.val = (unsigned short)0;
+        *(*table)++ = this;             /* make a table to force an error */
+        *(*table)++ = this;
+        *bits = 1;
+        return 0;     /* no symbols, but wait for decoding to report error */
+    }
+    for (min = 1; min <= MAXBITS; min++)
+        if (count[min] != 0) break;
+    if (root < min) root = min;
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1;
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1;
+        left -= count[len];
+        if (left < 0) return -1;        /* over-subscribed */
+    }
+    if (left > 0 && (type == CODES || max != 1))
+        return -1;                      /* incomplete set */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + count[len];
+
+    /* sort symbols by length, by symbol order within each length */
+    for (sym = 0; sym < codes; sym++)
+        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+
+    /*
+       Create and fill in decoding tables.  In this loop, the table being
+       filled is at next and has curr index bits.  The code being used is huff
+       with length len.  That code is converted to an index by dropping drop
+       bits off of the bottom.  For codes where len is less than drop + curr,
+       those top drop + curr - len bits are incremented through all values to
+       fill the table with replicated entries.
+
+       root is the number of index bits for the root table.  When len exceeds
+       root, sub-tables are created pointed to by the root entry with an index
+       of the low root bits of huff.  This is saved in low to check for when a
+       new sub-table should be started.  drop is zero when the root table is
+       being filled, and drop is root when sub-tables are being filled.
+
+       When a new sub-table is needed, it is necessary to look ahead in the
+       code lengths to determine what size sub-table is needed.  The length
+       counts are used for this, and so count[] is decremented as codes are
+       entered in the tables.
+
+       used keeps track of how many table entries have been allocated from the
+       provided *table space.  It is checked when a LENS table is being made
+       against the space in *table, ENOUGH, minus the maximum space needed by
+       the worst case distance code, MAXD.  This should never happen, but the
+       sufficiency of ENOUGH has not been proven exhaustively, hence the check.
+       This assumes that when type == LENS, bits == 9.
+
+       sym increments through all symbols, and the loop terminates when
+       all codes of length max, i.e. all codes, have been processed.  This
+       routine permits incomplete codes, so another loop after this one fills
+       in the rest of the decoding tables with invalid code markers.
+     */
+
+    /* set up for code type */
+    switch (type) {
+    case CODES:
+        base = extra = work;    /* dummy value--not used */
+        end = 19;
+        break;
+    case LENS:
+        base = lbase;
+        base -= 257;
+        extra = lext;
+        extra -= 257;
+        end = 256;
+        break;
+    default:            /* DISTS */
+        base = dbase;
+        extra = dext;
+        end = -1;
+    }
+
+    /* initialize state for loop */
+    huff = 0;                   /* starting code */
+    sym = 0;                    /* starting code symbol */
+    len = min;                  /* starting code length */
+    next = *table;              /* current table to fill in */
+    curr = root;                /* current table index bits */
+    drop = 0;                   /* current bits to drop from code for index */
+    low = (unsigned)(-1);       /* trigger new sub-table when len > root */
+    used = 1U << root;          /* use root table entries */
+    mask = used - 1;            /* mask for comparing low */
+
+    /* check available table space */
+    if (type == LENS && used >= ENOUGH - MAXD)
+        return 1;
+
+    /* process all codes and make table entries */
+    for (;;) {
+        /* create table entry */
+        this.bits = (unsigned char)(len - drop);
+        if ((int)(work[sym]) < end) {
+            this.op = (unsigned char)0;
+            this.val = work[sym];
+        }
+        else if ((int)(work[sym]) > end) {
+            this.op = (unsigned char)(extra[work[sym]]);
+            this.val = base[work[sym]];
+        }
+        else {
+            this.op = (unsigned char)(32 + 64);         /* end of block */
+            this.val = 0;
+        }
+
+        /* replicate for those indices with low len bits equal to huff */
+        incr = 1U << (len - drop);
+        fill = 1U << curr;
+        min = fill;                 /* save offset to next table */
+        do {
+            fill -= incr;
+            next[(huff >> drop) + fill] = this;
+        } while (fill != 0);
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+
+        /* go to next symbol, update count, len */
+        sym++;
+        if (--(count[len]) == 0) {
+            if (len == max) break;
+            len = lens[work[sym]];
+        }
+
+        /* create new sub-table if needed */
+        if (len > root && (huff & mask) != low) {
+            /* if first time, transition to sub-tables */
+            if (drop == 0)
+                drop = root;
+
+            /* increment past last table */
+            next += min;            /* here min is 1 << curr */
+
+            /* determine length of next table */
+            curr = len - drop;
+            left = (int)(1 << curr);
+            while (curr + drop < max) {
+                left -= count[curr + drop];
+                if (left <= 0) break;
+                curr++;
+                left <<= 1;
+            }
+
+            /* check for enough space */
+            used += 1U << curr;
+            if (type == LENS && used >= ENOUGH - MAXD)
+                return 1;
+
+            /* point entry in root table to sub-table */
+            low = huff & mask;
+            (*table)[low].op = (unsigned char)curr;
+            (*table)[low].bits = (unsigned char)root;
+            (*table)[low].val = (unsigned short)(next - *table);
+        }
+    }
+
+    /*
+       Fill in rest of table for incomplete codes.  This loop is similar to the
+       loop above in incrementing huff for table indices.  It is assumed that
+       len is equal to curr + drop, so there is no loop needed to increment
+       through high index bits.  When the current sub-table is filled, the loop
+       drops back to the root table to fill in any remaining entries there.
+     */
+    this.op = (unsigned char)64;                /* invalid code marker */
+    this.bits = (unsigned char)(len - drop);
+    this.val = (unsigned short)0;
+    while (huff != 0) {
+        /* when done with sub-table, drop back to root table */
+        if (drop != 0 && (huff & mask) != low) {
+            drop = 0;
+            len = root;
+            next = *table;
+            this.bits = (unsigned char)len;
+        }
+
+        /* put invalid code marker in table */
+        next[huff >> drop] = this;
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+    }
+
+    /* set return parameters */
+    *table += used;
+    *bits = root;
+    return 0;
+}

contrib/zlib/inftrees.h

@@ -0,0 +1,55 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables.  Each entry provides either the
+   information needed to do the operation requested by the code that
+   indexed that table entry, or it provides a pointer to another
+   table that indexes more bits of the code.  op indicates whether
+   the entry is a pointer to another table, a literal, a length or
+   distance, an end-of-block, or an invalid code.  For a table
+   pointer, the low four bits of op is the number of index bits of
+   that table.  For a length or distance, the low four bits of op
+   is the number of extra bits to get after the code.  bits is
+   the number of bits in this code or part of the code to drop off
+   of the bit buffer.  val is the actual byte to output in the case
+   of a literal, the base length or distance, or the offset from
+   the current table to the next table.  Each entry is four bytes. */
+typedef struct {
+    unsigned char op;           /* operation, extra bits, table bits */
+    unsigned char bits;         /* bits in this part of the code */
+    unsigned short val;         /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+    00000000 - literal
+    0000tttt - table link, tttt != 0 is the number of table index bits
+    0001eeee - length or distance, eeee is the number of extra bits
+    01100000 - end of block
+    01000000 - invalid code
+ */
+
+/* Maximum size of dynamic tree.  The maximum found in a long but non-
+   exhaustive search was 1444 code structures (852 for length/literals
+   and 592 for distances, the latter actually the result of an
+   exhaustive search).  The true maximum is not known, but the value
+   below is more than safe. */
+#define ENOUGH 2048
+#define MAXD 592
+
+/* Type of code to build for inftable() */
+typedef enum {
+    CODES,
+    LENS,
+    DISTS
+} codetype;
+
+extern int inflate_table OF((codetype type, unsigned short FAR *lens,
+                             unsigned codes, code FAR * FAR *table,
+                             unsigned FAR *bits, unsigned short FAR *work));

contrib/zlib/zconf.h

@@ -0,0 +1,332 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_          z_deflateInit_
+#  define deflate               z_deflate
+#  define deflateEnd            z_deflateEnd
+#  define inflateInit_          z_inflateInit_
+#  define inflate               z_inflate
+#  define inflateEnd            z_inflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateCopy           z_deflateCopy
+#  define deflateReset          z_deflateReset
+#  define deflateParams         z_deflateParams
+#  define deflateBound          z_deflateBound
+#  define deflatePrime          z_deflatePrime
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateCopy           z_inflateCopy
+#  define inflateReset          z_inflateReset
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define compress              z_compress
+#  define compress2             z_compress2
+#  define compressBound         z_compressBound
+#  define uncompress            z_uncompress
+#  define adler32               z_adler32
+#  define crc32                 z_crc32
+#  define get_crc_table         z_get_crc_table
+#  define zError                z_zError
+
+#  define alloc_func            z_alloc_func
+#  define free_func             z_free_func
+#  define in_func               z_in_func
+#  define out_func              z_out_func
+#  define Byte                  z_Byte
+#  define uInt                  z_uInt
+#  define uLong                 z_uLong
+#  define Bytef                 z_Bytef
+#  define charf                 z_charf
+#  define intf                  z_intf
+#  define uIntf                 z_uIntf
+#  define uLongf                z_uLongf
+#  define voidpf                z_voidpf
+#  define voidp                 z_voidp
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if 0           /* HAVE_UNISTD_H -- this line is updated by ./configure */
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  ifdef VMS
+#    include <unixio.h>   /* for off_t */
+#  endif
+#  define z_off_t off_t
+#endif
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if defined(__OS400__)
+#  define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+#  define NO_vsnprintf
+#  ifdef FAR
+#    undef FAR
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(deflateBound,"DEBND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(compressBound,"CMBND")
+#   pragma map(inflate_table,"INTABL")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */

contrib/zlib/zconf.in.h

@@ -0,0 +1,332 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ */
+#ifdef Z_PREFIX
+#  define deflateInit_          z_deflateInit_
+#  define deflate               z_deflate
+#  define deflateEnd            z_deflateEnd
+#  define inflateInit_          z_inflateInit_
+#  define inflate               z_inflate
+#  define inflateEnd            z_inflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateCopy           z_deflateCopy
+#  define deflateReset          z_deflateReset
+#  define deflateParams         z_deflateParams
+#  define deflateBound          z_deflateBound
+#  define deflatePrime          z_deflatePrime
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateCopy           z_inflateCopy
+#  define inflateReset          z_inflateReset
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define compress              z_compress
+#  define compress2             z_compress2
+#  define compressBound         z_compressBound
+#  define uncompress            z_uncompress
+#  define adler32               z_adler32
+#  define crc32                 z_crc32
+#  define get_crc_table         z_get_crc_table
+#  define zError                z_zError
+
+#  define alloc_func            z_alloc_func
+#  define free_func             z_free_func
+#  define in_func               z_in_func
+#  define out_func              z_out_func
+#  define Byte                  z_Byte
+#  define uInt                  z_uInt
+#  define uLong                 z_uLong
+#  define Bytef                 z_Bytef
+#  define charf                 z_charf
+#  define intf                  z_intf
+#  define uIntf                 z_uIntf
+#  define uLongf                z_uLongf
+#  define voidpf                z_voidpf
+#  define voidp                 z_voidp
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if 0           /* HAVE_UNISTD_H -- this line is updated by ./configure */
+#  include <sys/types.h> /* for off_t */
+#  include <unistd.h>    /* for SEEK_* and off_t */
+#  ifdef VMS
+#    include <unixio.h>   /* for off_t */
+#  endif
+#  define z_off_t off_t
+#endif
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if defined(__OS400__)
+#  define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+#  define NO_vsnprintf
+#  ifdef FAR
+#    undef FAR
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+#   pragma map(deflateInit_,"DEIN")
+#   pragma map(deflateInit2_,"DEIN2")
+#   pragma map(deflateEnd,"DEEND")
+#   pragma map(deflateBound,"DEBND")
+#   pragma map(inflateInit_,"ININ")
+#   pragma map(inflateInit2_,"ININ2")
+#   pragma map(inflateEnd,"INEND")
+#   pragma map(inflateSync,"INSY")
+#   pragma map(inflateSetDictionary,"INSEDI")
+#   pragma map(compressBound,"CMBND")
+#   pragma map(inflate_table,"INTABL")
+#   pragma map(inflate_fast,"INFA")
+#   pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */

contrib/zlib/zlib.h

@@ -0,0 +1,357 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.3, July 18th, 2005
+
+  Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  [email protected]          [email protected]
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.3"
+#define ZLIB_VERNUM 0x1230
+
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative
+ * values are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+
+
+
+typedef voidp gzFile;
+
+ZEXTERN gzFile ZEXPORT gzopen  OF((const char *path, const char *mode));
+
+ZEXTERN gzFile ZEXPORT gzdopen  OF((int fd, const char *mode));
+
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+
+
+ZEXTERN int ZEXPORT    gzread  OF((gzFile file, voidp buf, unsigned len));
+
+ZEXTERN int ZEXPORT    gzwrite OF((gzFile file,
+                                   voidpc buf, unsigned len));
+
+
+ZEXTERN int ZEXPORTVA   gzprintf OF((gzFile file, const char *format, ...));
+
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+
+ZEXTERN int ZEXPORT    gzputc OF((gzFile file, int c));
+
+
+ZEXTERN int ZEXPORT    gzgetc OF((gzFile file));
+
+
+ZEXTERN int ZEXPORT    gzungetc OF((int c, gzFile file));
+
+ZEXTERN int ZEXPORT    gzflush OF((gzFile file, int flush));
+
+
+ZEXTERN z_off_t ZEXPORT    gzseek OF((gzFile file,
+                                      z_off_t offset, int whence));
+
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+
+
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+
+
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+
+
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+        inflateBackInit_((strm), (windowBits), (window), \
+        ZLIB_VERSION, sizeof(z_stream))
+
+
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;}; /* hack for buggy compilers */
+#endif
+
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp z));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */

contrib/zlib/zutil.c

@@ -0,0 +1,318 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+
+#ifndef NO_DUMMY_DECL
+struct internal_state      {int dummy;}; /* for buggy compilers */
+#endif
+
+const char * const z_errmsg[10] = {
+"need dictionary",     /* Z_NEED_DICT       2  */
+"stream end",          /* Z_STREAM_END      1  */
+"",                    /* Z_OK              0  */
+"file error",          /* Z_ERRNO         (-1) */
+"stream error",        /* Z_STREAM_ERROR  (-2) */
+"data error",          /* Z_DATA_ERROR    (-3) */
+"insufficient memory", /* Z_MEM_ERROR     (-4) */
+"buffer error",        /* Z_BUF_ERROR     (-5) */
+"incompatible version",/* Z_VERSION_ERROR (-6) */
+""};
+
+
+const char * ZEXPORT zlibVersion()
+{
+    return ZLIB_VERSION;
+}
+
+uLong ZEXPORT zlibCompileFlags()
+{
+    uLong flags;
+
+    flags = 0;
+    switch (sizeof(uInt)) {
+    case 2:     break;
+    case 4:     flags += 1;     break;
+    case 8:     flags += 2;     break;
+    default:    flags += 3;
+    }
+    switch (sizeof(uLong)) {
+    case 2:     break;
+    case 4:     flags += 1 << 2;        break;
+    case 8:     flags += 2 << 2;        break;
+    default:    flags += 3 << 2;
+    }
+    switch (sizeof(voidpf)) {
+    case 2:     break;
+    case 4:     flags += 1 << 4;        break;
+    case 8:     flags += 2 << 4;        break;
+    default:    flags += 3 << 4;
+    }
+    switch (sizeof(z_off_t)) {
+    case 2:     break;
+    case 4:     flags += 1 << 6;        break;
+    case 8:     flags += 2 << 6;        break;
+    default:    flags += 3 << 6;
+    }
+#ifdef DEBUG
+    flags += 1 << 8;
+#endif
+#if defined(ASMV) || defined(ASMINF)
+    flags += 1 << 9;
+#endif
+#ifdef ZLIB_WINAPI
+    flags += 1 << 10;
+#endif
+#ifdef BUILDFIXED
+    flags += 1 << 12;
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+    flags += 1 << 13;
+#endif
+#ifdef NO_GZCOMPRESS
+    flags += 1L << 16;
+#endif
+#ifdef NO_GZIP
+    flags += 1L << 17;
+#endif
+#ifdef PKZIP_BUG_WORKAROUND
+    flags += 1L << 20;
+#endif
+#ifdef FASTEST
+    flags += 1L << 21;
+#endif
+#ifdef STDC
+#  ifdef NO_vsnprintf
+        flags += 1L << 25;
+#    ifdef HAS_vsprintf_void
+        flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_vsnprintf_void
+        flags += 1L << 26;
+#    endif
+#  endif
+#else
+        flags += 1L << 24;
+#  ifdef NO_snprintf
+        flags += 1L << 25;
+#    ifdef HAS_sprintf_void
+        flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_snprintf_void
+        flags += 1L << 26;
+#    endif
+#  endif
+#endif
+    return flags;
+}
+
+#ifdef DEBUG
+
+#  ifndef verbose
+#    define verbose 0
+#  endif
+int z_verbose = verbose;
+
+void z_error (m)
+    char *m;
+{
+    fprintf(stderr, "%s\n", m);
+    exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+    int err;
+{
+    return ERR_MSG(err);
+}
+
+#if defined(_WIN32_WCE)
+    /* The Microsoft C Run-Time Library for Windows CE doesn't have
+     * errno.  We define it as a global variable to simplify porting.
+     * Its value is always 0 and should not be used.
+     */
+    int errno = 0;
+#endif
+
+#ifndef HAVE_MEMCPY
+
+void zmemcpy(dest, source, len)
+    Bytef* dest;
+    const Bytef* source;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = *source++; /* ??? to be unrolled */
+    } while (--len != 0);
+}
+
+int zmemcmp(s1, s2, len)
+    const Bytef* s1;
+    const Bytef* s2;
+    uInt  len;
+{
+    uInt j;
+
+    for (j = 0; j < len; j++) {
+        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+    }
+    return 0;
+}
+
+void zmemzero(dest, len)
+    Bytef* dest;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = 0;  /* ??? to be unrolled */
+    } while (--len != 0);
+}
+#endif
+
+
+#ifdef SYS16BIT
+
+#ifdef __TURBOC__
+/* Turbo C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+    voidpf org_ptr;
+    voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    voidpf buf = opaque; /* just to make some compilers happy */
+    ulg bsize = (ulg)items*size;
+
+    /* If we allocate less than 65520 bytes, we assume that farmalloc
+     * will return a usable pointer which doesn't have to be normalized.
+     */
+    if (bsize < 65520L) {
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
+    } else {
+        buf = farmalloc(bsize + 16L);
+    }
+    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+    table[next_ptr].org_ptr = buf;
+
+    /* Normalize the pointer to seg:0 */
+    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+    *(ush*)&buf = 0;
+    table[next_ptr++].new_ptr = buf;
+    return buf;
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    int n;
+    if (*(ush*)&ptr != 0) { /* object < 64K */
+        farfree(ptr);
+        return;
+    }
+    /* Find the original pointer */
+    for (n = 0; n < next_ptr; n++) {
+        if (ptr != table[n].new_ptr) continue;
+
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
+    }
+    ptr = opaque; /* just to make some compilers happy */
+    Assert(0, "zcfree: ptr not found");
+}
+
+#endif /* __TURBOC__ */
+
+
+#ifdef M_I86
+/* Microsoft C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+#  define _halloc  halloc
+#  define _hfree   hfree
+#endif
+
+voidpf zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    return _halloc((long)items, size);
+}
+
+void  zcfree (voidpf opaque, voidpf ptr)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    _hfree(ptr);
+}
+
+#endif /* M_I86 */
+
+#endif /* SYS16BIT */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp  malloc OF((uInt size));
+extern voidp  calloc OF((uInt items, uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+voidpf zcalloc (opaque, items, size)
+    voidpf opaque;
+    unsigned items;
+    unsigned size;
+{
+    if (opaque) items += size - size; /* make compiler happy */
+    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+                              (voidpf)calloc(items, size);
+}
+
+void  zcfree (opaque, ptr)
+    voidpf opaque;
+    voidpf ptr;
+{
+    free(ptr);
+    if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */

contrib/zlib/zutil.h

@@ -0,0 +1,269 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2005 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+#ifdef STDC
+#  ifndef _WIN32_WCE
+#    include <stddef.h>
+#  endif
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+#   ifdef _WIN32_WCE
+      /* The Microsoft C Run-Time Library for Windows CE doesn't have
+       * errno.  We define it as a global variable to simplify porting.
+       * Its value is always 0 and should not be used.  We rename it to
+       * avoid conflict with other libraries that use the same workaround.
+       */
+#     define errno z_errno
+#   endif
+    extern int errno;
+#else
+#  ifndef _WIN32_WCE
+#    include <errno.h>
+#  endif
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = (char*)ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#  define OS_CODE  0x00
+#  if defined(__TURBOC__) || defined(__BORLANDC__)
+#    if(__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+       /* Allow compilation with ANSI keywords only enabled */
+       void _Cdecl farfree( void *block );
+       void *_Cdecl farmalloc( unsigned long nbytes );
+#    else
+#      include <alloc.h>
+#    endif
+#  else /* MSC or DJGPP */
+#    include <malloc.h>
+#  endif
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  0x02
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  0x05
+#endif
+
+#ifdef OS2
+#  define OS_CODE  0x06
+#  ifdef M_I86
+     #include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  0x07
+#  if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#    include <unix.h> /* for fdopen */
+#  else
+#    ifndef fdopen
+#      define fdopen(fd,mode) NULL /* No fdopen() */
+#    endif
+#  endif
+#endif
+
+#ifdef TOPS20
+#  define OS_CODE  0x0a
+#endif
+
+#ifdef WIN32
+#  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
+#    define OS_CODE  0x0b
+#  endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#  define OS_CODE  0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600))
+#  if defined(_WIN32_WCE)
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#    ifndef _PTRDIFF_T_DEFINED
+       typedef int ptrdiff_t;
+#      define _PTRDIFF_T_DEFINED
+#    endif
+#  else
+#    define fdopen(fd,type)  _fdopen(fd,type)
+#  endif
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+#if defined(__CYGWIN__)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+#ifndef HAVE_VSNPRINTF
+#  ifdef MSDOS
+     /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+        but for now we just assume it doesn't. */
+#    define NO_vsnprintf
+#  endif
+#  ifdef __TURBOC__
+#    define NO_vsnprintf
+#  endif
+#  ifdef WIN32
+     /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
+#      define vsnprintf _vsnprintf
+#    endif
+#  endif
+#  ifdef __SASC
+#    define NO_vsnprintf
+#  endif
+#endif
+#ifdef VMS
+#  define NO_vsnprintf
+#endif
+
+#if defined(pyr)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   extern void zmemcpy  OF((Bytef* dest, const Bytef* source, uInt len));
+   extern int  zmemcmp  OF((const Bytef* s1, const Bytef* s2, uInt len));
+   extern void zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef DEBUG
+#  include <stdio.h>
+   extern int z_verbose;
+   extern void z_error    OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+
+voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size));
+void   zcfree  OF((voidpf opaque, voidpf ptr));
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+#endif /* ZUTIL_H */

contrib/zlib_note.txt

@@ -0,0 +1,12 @@
+This is a heavily modified and shrinked version of zlib 1.2.3
+
+- Removed comments from zlib.h
+- Removed gzip/zip archive I/O
+- Removed Compression part
+- Removed infback.c
+- Added Assimp #idefs to exclude it if not needed
+
+All inflateNNN functions are available, for the rest you need to try.
+If a function is needed but is not there, get zlib and add the 
+corresponding files to the repos. zlib is quite clean, it shouldn't
+be too difficult to configure it to your needs.

include/aiConfig.h

@@ -159,7 +159,7 @@ ASSIMP_API unsigned int aiGetVersionRevision ();
  *	basing on the smoothing groups loaded from the file.
  * 
  * Many ASE files have invalid normals (they're not orthonormal).
- * Property type: integer (0: false; !0: true). Default value: false.
+ * Property type: integer (0: false; !0: true). Default value: true.
  */
 #define AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS	"imp.ase.reconn"
 

include/aiDefines.h

@@ -53,7 +53,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	// build in this case. 'XX' stands for the most common file
 	// extension of the file format. E.g.: 
     // ASSIMP_BUILD_NO_X_IMPORTER disables the X loader.
-	// ================================================================
+	//
+	// Other configuration switches:
+	//    ASSIMP_BUILD_NO_COMPRESSED_X 
+	//      - Disable support for compressed X files, removes the
+	//        dependency from the zlib inflate algorithm.
+	//
+	// ================================================================
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_X
+#	define ASSIMP_BUILD_NEED_Z_INFLATE
+#endif
 
 	// ================================================================
 	// Define ASSIMP_BUILD_NO_XX_PROCESS to disable a specific

workspaces/SCons/SConstruct

@@ -1,44 +1,44 @@
-#------------------------------------------------------------------------------
-# ASSIMP scons build file
-#
-#------------------------------------------------------------------------------
-import sys
-
-#------------------------------------------------------------------------------
-g_LibPath = Split("""
-	./
-	/usr/lib/
-	/usr/local/lib/
-""")
-#------------------------------------------------------------------------------
-g_IncPath = Split("""
-	../../code/
-	/usr/include/
-	/usr/local/include/
-""")
-#------------------------------------------------------------------------------
-g_assimp_lib_Source =  Glob(r"../../code/*.cpp") +     Glob(r"../../code/irrXML/*.cpp") +    Glob(r"../../code/extra/*.cpp") 
-
-#------------------------------------------------------------------------------
-# don't reset CC/CXX-variable, other users might have set it to something special
-#------------------------------------------------------------------------------
-ccflags = '-pipe'
-
-if ARGUMENTS.get('debug', 0):
-	print "Using Debug Build!"
-	ccflags = ccflags + ' -g -pg -Wall -pedantic '
-else:
-	ccflags = ccflags + ' -Os -fno-strict-aliasing -msse -Wall -pedantic'
-	
-env = Environment(CCFLAGS = ccflags, CPPPATH = g_IncPath, LIBPATH=g_LibPath)
-conf = Configure( env )
-
-#if not conf.CheckCHeader( "boost/thread/thread.hpp" ):
-#	print "Boost must be installed!"
-#	Exit( 1 )
-env = conf.Finish()
-
-# Build library
-env.StaticLibrary(target = "assimp", source = g_assimp_lib_Source, 
-		LIBPATH = g_LibPath)
-
+#------------------------------------------------------------------------------
+# ASSIMP scons build file
+#
+#------------------------------------------------------------------------------
+import sys
+
+#------------------------------------------------------------------------------
+g_LibPath = Split("""
+	./
+	/usr/lib/
+	/usr/local/lib/
+""")
+#------------------------------------------------------------------------------
+g_IncPath = Split("""
+	../../code/
+	/usr/include/
+	/usr/local/include/
+""")
+#------------------------------------------------------------------------------
+g_assimp_lib_Source =  Glob(r"../../code/*.cpp") +     Glob(r"../../contrib/irrXML/*.cpp") + Glob(r"../../contrib/zlib/*.c") + Glob(r"../../code/extra/*.cpp") 
+
+#------------------------------------------------------------------------------
+# don't reset CC/CXX-variable, other users might have set it to something special
+#------------------------------------------------------------------------------
+ccflags = '-pipe'
+
+if ARGUMENTS.get('debug', 0):
+	print "Using Debug Build!"
+	ccflags = ccflags + ' -g -pg -Wall -pedantic '
+else:
+	ccflags = ccflags + ' -Os -fno-strict-aliasing -msse -Wall -pedantic'
+	
+env = Environment(CCFLAGS = ccflags, CPPPATH = g_IncPath, LIBPATH=g_LibPath)
+conf = Configure( env )
+
+#if not conf.CheckCHeader( "boost/thread/thread.hpp" ):
+#	print "Boost must be installed!"
+#	Exit( 1 )
+env = conf.Finish()
+
+# Build library
+env.StaticLibrary(target = "assimp", source = g_assimp_lib_Source, 
+		LIBPATH = g_LibPath)
+

workspaces/vc8/assimp.vcproj

@@ -1396,7 +1396,7 @@
 				>
 			</File>
 			<Filter
-				Name="extra"
+				Name="Extra"
 				>
 				<File
 					RelativePath="..\..\code\extra\MakeVerboseFormat.cpp"
@@ -1925,6 +1925,14 @@
 						RelativePath="..\..\code\IRRLoader.h"
 						>
 					</File>
+					<File
+						RelativePath="..\..\code\IRRShared.cpp"
+						>
+					</File>
+					<File
+						RelativePath="..\..\code\IRRShared.h"
+						>
+					</File>
 				</Filter>
 				<Filter
 					Name="Q3D"
@@ -2263,186 +2271,6 @@
 					</FileConfiguration>
 				</File>
 			</Filter>
-			<Filter
-				Name="irrXML"
-				>
-				<File
-					RelativePath="..\..\code\irrXML\CXMLReaderImpl.h"
-					>
-				</File>
-				<File
-					RelativePath="..\..\code\irrXML\heapsort.h"
-					>
-				</File>
-				<File
-					RelativePath="..\..\code\irrXML\irrArray.h"
-					>
-				</File>
-				<File
-					RelativePath="..\..\code\irrXML\irrString.h"
-					>
-				</File>
-				<File
-					RelativePath="..\..\code\irrXML\irrTypes.h"
-					>
-				</File>
-				<File
-					RelativePath="..\..\code\irrXML\irrXML.cpp"
-					>
-					<FileConfiguration
-						Name="debug|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="true"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="debug|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="false"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release-dll|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="false"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release-dll|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="debug-dll|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="false"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="debug-dll|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release-noboost-st|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="false"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release-noboost-st|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="debug-noboost-st|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="true"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="debug-noboost-st|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="debug-st|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="true"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="debug-st|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release-st|Win32"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							BasicRuntimeChecks="0"
-							SmallerTypeCheck="false"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-					<FileConfiguration
-						Name="release-st|x64"
-						>
-						<Tool
-							Name="VCCLCompilerTool"
-							UsePrecompiledHeader="0"
-						/>
-					</FileConfiguration>
-				</File>
-				<File
-					RelativePath="..\..\code\irrXML\irrXML.h"
-					>
-				</File>
-				<File
-					RelativePath="..\..\code\irrXML\irrXMLWrapper.h"
-					>
-				</File>
-			</Filter>
 			<Filter
 				Name="Logging"
 				>
@@ -2519,6 +2347,1010 @@
 					>
 				</File>
 			</Filter>
+			<Filter
+				Name="Extern"
+				>
+				<Filter
+					Name="irrXML"
+					>
+					<File
+						RelativePath="..\..\contrib\irrXML\CXMLReaderImpl.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\irrXML\fast_atof.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\irrXML\heapsort.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\irrXML\irrArray.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\irrXML\irrString.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\irrXML\irrTypes.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\irrXML\irrXML.cpp"
+						>
+						<FileConfiguration
+							Name="debug|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\..\contrib\irrXML\irrXML.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\code\irrXMLWrapper.h"
+						>
+					</File>
+				</Filter>
+				<Filter
+					Name="zLib"
+					>
+					<File
+						RelativePath="..\..\contrib\zlib\adler32.c"
+						>
+						<FileConfiguration
+							Name="debug|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\crc32.c"
+						>
+						<FileConfiguration
+							Name="debug|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\crc32.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\inffast.c"
+						>
+						<FileConfiguration
+							Name="debug|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\inffast.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\inffixed.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\inflate.c"
+						>
+						<FileConfiguration
+							Name="debug|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\inflate.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\inftrees.c"
+						>
+						<FileConfiguration
+							Name="debug|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\inftrees.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\zconf.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\zconf.in.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\zlib.h"
+						>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\zutil.c"
+						>
+						<FileConfiguration
+							Name="debug|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-dll|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-noboost-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="debug-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|Win32"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+						<FileConfiguration
+							Name="release-st|x64"
+							>
+							<Tool
+								Name="VCCLCompilerTool"
+								UsePrecompiledHeader="0"
+							/>
+						</FileConfiguration>
+					</File>
+					<File
+						RelativePath="..\..\contrib\zlib\zutil.h"
+						>
+					</File>
+				</Filter>
+			</Filter>
 		</Filter>
 		<Filter
 			Name="doc"