v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into patch-4

pull/5159/head
Kim Kulling 2023-07-11 10:19:38 +02:00 committed by GitHub
parent 46ea0a7d7c 53846430ce
commit 11f024b395
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
126 changed files with 22198 additions and 10566 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@ -268,6 +268,11 @@ IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT MINGW)
SET(CMAKE_CXX_STANDARD 17) SET(CMAKE_CXX_STANDARD 17)
SET(CMAKE_POSITION_INDEPENDENT_CODE ON) SET(CMAKE_POSITION_INDEPENDENT_CODE ON)
ENDIF() ENDIF()
IF(CMAKE_CXX_COMPILER_VERSION GREATER_EQUAL 13)
MESSAGE(STATUS "GCC13 detected disabling \"-Wdangling-reference\" in Cpp files as it appears to be a false positive")
ADD_COMPILE_OPTIONS("$<$<COMPILE_LANGUAGE:CXX>:-Wno-dangling-reference>")
ENDIF()
# hide all not-exported symbols # hide all not-exported symbols
IF(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "mips64" ) IF(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "mips64" )
SET(CMAKE_CXX_FLAGS "-mxgot -fvisibility=hidden -fno-strict-aliasing -Wall ${CMAKE_CXX_FLAGS}") SET(CMAKE_CXX_FLAGS "-mxgot -fvisibility=hidden -fno-strict-aliasing -Wall ${CMAKE_CXX_FLAGS}")

5
code/AssetLib/ASE/ASEParser.cpp
View File

@ -479,6 +479,11 @@ void Parser::ParseLV1MaterialListBlock() {
if (TokenMatch(filePtr, "MATERIAL_COUNT", 14)) { if (TokenMatch(filePtr, "MATERIAL_COUNT", 14)) {
ParseLV4MeshLong(iMaterialCount); ParseLV4MeshLong(iMaterialCount);
if (UINT_MAX - iOldMaterialCount < iMaterialCount) {
LogWarning("Out of range: material index is too large");
return;
}
// now allocate enough storage to hold all materials // now allocate enough storage to hold all materials
m_vMaterials.resize(iOldMaterialCount + iMaterialCount, Material("INVALID")); m_vMaterials.resize(iOldMaterialCount + iMaterialCount, Material("INVALID"));
continue; continue;

120
code/AssetLib/Blender/BlenderLoader.cpp
View File

@ -115,15 +115,12 @@ BlenderImporter::~BlenderImporter() {
delete modifier_cache; delete modifier_cache;
} }
static const char * const Tokens[] = { "BLENDER" }; static const char Token[] = "BLENDER";
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file. // Returns whether the class can handle the format of the given file.
bool BlenderImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { bool BlenderImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
// note: this won't catch compressed files return ParseMagicToken(pFile, pIOHandler).error.empty();
static const char *tokens[] = { "<BLENDER", "blender" };
return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -142,63 +139,21 @@ void BlenderImporter::SetupProperties(const Importer * /*pImp*/) {
// Imports the given file into the given scene structure. // Imports the given file into the given scene structure.
void BlenderImporter::InternReadFile(const std::string &pFile, void BlenderImporter::InternReadFile(const std::string &pFile,
aiScene *pScene, IOSystem *pIOHandler) { aiScene *pScene, IOSystem *pIOHandler) {
#ifndef ASSIMP_BUILD_NO_COMPRESSED_BLEND
std::vector<char> uncompressed;
#endif
FileDatabase file; FileDatabase file;
std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb")); StreamOrError streamOrError = ParseMagicToken(pFile, pIOHandler);
if (!stream) { if (!streamOrError.error.empty()) {
ThrowException("Could not open file for reading"); ThrowException(streamOrError.error);
} }
std::shared_ptr<IOStream> stream = std::move(streamOrError.stream);
char magic[8] = { 0 }; char version[4] = { 0 };
stream->Read(magic, 7, 1); file.i64bit = (stream->Read(version, 1, 1), version[0] == '-');
if (strcmp(magic, Tokens[0])) { file.little = (stream->Read(version, 1, 1), version[0] == 'v');
// Check for presence of the gzip header. If yes, assume it is a
// compressed blend file and try uncompressing it, else fail. This is to
// avoid uncompressing random files which our loader might end up with.
#ifdef ASSIMP_BUILD_NO_COMPRESSED_BLEND
ThrowException("BLENDER magic bytes are missing, is this file compressed (Assimp was built without decompression support)?");
#else
if (magic[0] != 0x1f || static_cast<uint8_t>(magic[1]) != 0x8b) {
ThrowException("BLENDER magic bytes are missing, couldn't find GZIP header either");
}
LogDebug("Found no BLENDER magic word but a GZIP header, might be a compressed file"); stream->Read(version, 3, 1);
if (magic[2] != 8) { version[3] = '\0';
ThrowException("Unsupported GZIP compression method");
}
// http://www.gzip.org/zlib/rfc-gzip.html#header-trailer LogInfo("Blender version is ", version[0], ".", version + 1,
stream->Seek(0L, aiOrigin_SET);
std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
size_t total = 0;
Compression compression;
if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, 16 + Compression::MaxWBits)) {
total = compression.decompress((unsigned char *)reader->GetPtr(), reader->GetRemainingSize(), uncompressed);
compression.close();
}
// replace the input stream with a memory stream
stream = std::make_shared<MemoryIOStream>(reinterpret_cast<uint8_t *>(uncompressed.data()), total);
// .. and retry
stream->Read(magic, 7, 1);
if (strcmp(magic, "BLENDER")) {
ThrowException("Found no BLENDER magic word in decompressed GZIP file");
}
#endif
}
file.i64bit = (stream->Read(magic, 1, 1), magic[0] == '-');
file.little = (stream->Read(magic, 1, 1), magic[0] == 'v');
stream->Read(magic, 3, 1);
magic[3] = '\0';
LogInfo("Blender version is ", magic[0], ".", magic + 1,
" (64bit: ", file.i64bit ? "true" : "false", " (64bit: ", file.i64bit ? "true" : "false",
", little endian: ", file.little ? "true" : "false", ")"); ", little endian: ", file.little ? "true" : "false", ")");
@ -1338,4 +1293,55 @@ aiNode *BlenderImporter::ConvertNode(const Scene &in, const Object *obj, Convers
return node.release(); return node.release();
} }
BlenderImporter::StreamOrError BlenderImporter::ParseMagicToken(const std::string &pFile, IOSystem *pIOHandler) const {
std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb"));
if (stream == nullptr) {
return {{}, {}, "Could not open file for reading"};
}
char magic[8] = { 0 };
stream->Read(magic, 7, 1);
if (strcmp(magic, Token) == 0) {
return {stream, {}, {}};
}
// Check for presence of the gzip header. If yes, assume it is a
// compressed blend file and try uncompressing it, else fail. This is to
// avoid uncompressing random files which our loader might end up with.
#ifdef ASSIMP_BUILD_NO_COMPRESSED_BLEND
return {{}, {}, "BLENDER magic bytes are missing, is this file compressed (Assimp was built without decompression support)?"};
#else
if (magic[0] != 0x1f || static_cast<uint8_t>(magic[1]) != 0x8b) {
return {{}, {}, "BLENDER magic bytes are missing, couldn't find GZIP header either"};
}
LogDebug("Found no BLENDER magic word but a GZIP header, might be a compressed file");
if (magic[2] != 8) {
return {{}, {}, "Unsupported GZIP compression method"};
}
// http://www.gzip.org/zlib/rfc-gzip.html#header-trailer
stream->Seek(0L, aiOrigin_SET);
std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
size_t total = 0;
Compression compression;
auto uncompressed = std::make_shared<std::vector<char>>();
if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, 16 + Compression::MaxWBits)) {
total = compression.decompress((unsigned char *)reader->GetPtr(), reader->GetRemainingSize(), *uncompressed);
compression.close();
}
// replace the input stream with a memory stream
stream = std::make_shared<MemoryIOStream>(reinterpret_cast<uint8_t *>(uncompressed->data()), total);
// .. and retry
stream->Read(magic, 7, 1);
if (strcmp(magic, Token) == 0) {
return {stream, uncompressed, {}};
}
return {{}, {}, "Found no BLENDER magic word in decompressed GZIP file"};
#endif
}
#endif // ASSIMP_BUILD_NO_BLEND_IMPORTER #endif // ASSIMP_BUILD_NO_BLEND_IMPORTER

13
code/AssetLib/Blender/BlenderLoader.h
View File

@ -180,6 +180,19 @@ private:
const Blender::MTex *tex, const Blender::MTex *tex,
Blender::ConversionData &conv_data); Blender::ConversionData &conv_data);
// TODO: Move to a std::variant, once c++17 is supported.
struct StreamOrError {
std::shared_ptr<IOStream> stream;
std::shared_ptr<std::vector<char>> input;
std::string error;
};
// Returns either a stream (and optional input data for the stream) or
// an error if it can't parse the magic token.
StreamOrError ParseMagicToken(
const std::string &pFile,
IOSystem *pIOHandler) const;
private: // static stuff, mostly logging and error reporting. private: // static stuff, mostly logging and error reporting.
// -------------------- // --------------------
static void CheckActualType(const Blender::ElemBase *dt, static void CheckActualType(const Blender::ElemBase *dt,

2137
code/AssetLib/Irr/IRRLoader.cpp
View File

File diff suppressed because it is too large Load Diff

143
code/AssetLib/Irr/IRRLoader.h
View File

@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/StringUtils.h> #include <assimp/StringUtils.h>
#include <assimp/anim.h> #include <assimp/anim.h>
namespace Assimp { namespace Assimp {
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
/** Irr importer class. /** Irr importer class.
@ -71,13 +71,13 @@ public:
/** Returns whether the class can handle the format of the given file. /** Returns whether the class can handle the format of the given file.
* See BaseImporter::CanRead() for details. * See BaseImporter::CanRead() for details.
*/ */
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
bool checkSig) const override; bool checkSig) const override;
protected: protected:
const aiImporterDesc* GetInfo () const override; const aiImporterDesc *GetInfo() const override;
void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override; void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
void SetupProperties(const Importer* pImp) override; void SetupProperties(const Importer *pImp) override;
private: private:
/** Data structure for a scene-graph node animator /** Data structure for a scene-graph node animator
@ -85,27 +85,19 @@ private:
struct Animator { struct Animator {
// Type of the animator // Type of the animator
enum AT { enum AT {
UNKNOWN = 0x0, UNKNOWN = 0x0,
ROTATION = 0x1, ROTATION = 0x1,
FLY_CIRCLE = 0x2, FLY_CIRCLE = 0x2,
FLY_STRAIGHT = 0x3, FLY_STRAIGHT = 0x3,
FOLLOW_SPLINE = 0x4, FOLLOW_SPLINE = 0x4,
OTHER = 0x5 OTHER = 0x5
} type; } type;
explicit Animator(AT t = UNKNOWN) explicit Animator(AT t = UNKNOWN) :
: type (t) type(t), speed(ai_real(0.001)), direction(ai_real(0.0), ai_real(1.0), ai_real(0.0)), circleRadius(ai_real(1.0)), tightness(ai_real(0.5)), loop(true), timeForWay(100) {
, speed ( ai_real( 0.001 ) )
, direction ( ai_real( 0.0 ), ai_real( 1.0 ), ai_real( 0.0 ) )
, circleRadius ( ai_real( 1.0) )
, tightness ( ai_real( 0.5 ) )
, loop (true)
, timeForWay (100)
{
} }
// common parameters // common parameters
ai_real speed; ai_real speed;
aiVector3D direction; aiVector3D direction;
@ -128,11 +120,9 @@ private:
/** Data structure for a scene-graph node in an IRR file /** Data structure for a scene-graph node in an IRR file
*/ */
struct Node struct Node {
{
// Type of the node // Type of the node
enum ET enum ET {
{
LIGHT, LIGHT,
CUBE, CUBE,
MESH, MESH,
@ -144,21 +134,20 @@ private:
ANIMMESH ANIMMESH
} type; } type;
explicit Node(ET t) explicit Node(ET t) :
: type (t) type(t), scaling(1.0, 1.0, 1.0) // assume uniform scaling by default
, scaling (1.0,1.0,1.0) // assume uniform scaling by default ,
, parent() parent(),
, framesPerSecond (0.0) framesPerSecond(0.0),
, id() id(),
, sphereRadius (1.0) sphereRadius(1.0),
, spherePolyCountX (100) spherePolyCountX(100),
, spherePolyCountY (100) spherePolyCountY(100) {
{
// Generate a default name for the node // Generate a default name for the node
char buffer[128]; char buffer[128];
static int cnt; static int cnt;
ai_snprintf(buffer, 128, "IrrNode_%i",cnt++); ai_snprintf(buffer, 128, "IrrNode_%i", cnt++);
name = std::string(buffer); name = std::string(buffer);
// reserve space for up to 5 materials // reserve space for up to 5 materials
@ -175,10 +164,10 @@ private:
std::string name; std::string name;
// List of all child nodes // List of all child nodes
std::vector<Node*> children; std::vector<Node *> children;
// Parent node // Parent node
Node* parent; Node *parent;
// Animated meshes: frames per second // Animated meshes: frames per second
// 0.f if not specified // 0.f if not specified
@ -190,13 +179,13 @@ private:
// Meshes: List of materials to be assigned // Meshes: List of materials to be assigned
// along with their corresponding material flags // along with their corresponding material flags
std::vector< std::pair<aiMaterial*, unsigned int> > materials; std::vector<std::pair<aiMaterial *, unsigned int>> materials;
// Spheres: radius of the sphere to be generates // Spheres: radius of the sphere to be generates
ai_real sphereRadius; ai_real sphereRadius;
// Spheres: Number of polygons in the x,y direction // Spheres: Number of polygons in the x,y direction
unsigned int spherePolyCountX,spherePolyCountY; unsigned int spherePolyCountX, spherePolyCountY;
// List of all animators assigned to the node // List of all animators assigned to the node
std::list<Animator> animators; std::list<Animator> animators;
@ -204,40 +193,54 @@ private:
/** Data structure for a vertex in an IRR skybox /** Data structure for a vertex in an IRR skybox
*/ */
struct SkyboxVertex struct SkyboxVertex {
{
SkyboxVertex() = default; SkyboxVertex() = default;
//! Construction from single vertex components //! Construction from single vertex components
SkyboxVertex(ai_real px, ai_real py, ai_real pz, SkyboxVertex(ai_real px, ai_real py, ai_real pz,
ai_real nx, ai_real ny, ai_real nz, ai_real nx, ai_real ny, ai_real nz,
ai_real uvx, ai_real uvy) ai_real uvx, ai_real uvy)
: position (px,py,pz) :
, normal (nx,ny,nz) position(px, py, pz), normal(nx, ny, nz), uv(uvx, uvy, 0.0) {}
, uv (uvx,uvy,0.0)
{}
aiVector3D position, normal, uv; aiVector3D position, normal, uv;
}; };
// -------------------------------------------------------------------
// Parse <node> tag from XML file and extract child node
// @param node XML node
// @param guessedMeshesContained number of extra guessed meshes
IRRImporter::Node *ParseNode(pugi::xml_node &node, BatchLoader& batch);
// -------------------------------------------------------------------
// Parse <attributes> tags within <node> tags and apply to scene node
// @param attributeNode XML child node
// @param nd Attributed scene node
void ParseNodeAttributes(pugi::xml_node &attributeNode, IRRImporter::Node *nd, BatchLoader& batch);
// -------------------------------------------------------------------
// Parse an <animator> node and attach an animator to a node
// @param animatorNode XML animator node
// @param nd Animated scene node
void ParseAnimators(pugi::xml_node &animatorNode, IRRImporter::Node *nd);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/// Fill the scene-graph recursively /// Fill the scene-graph recursively
void GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene, void GenerateGraph(Node *root, aiNode *rootOut, aiScene *scene,
BatchLoader& batch, BatchLoader &batch,
std::vector<aiMesh*>& meshes, std::vector<aiMesh *> &meshes,
std::vector<aiNodeAnim*>& anims, std::vector<aiNodeAnim *> &anims,
std::vector<AttachmentInfo>& attach, std::vector<AttachmentInfo> &attach,
std::vector<aiMaterial*>& materials, std::vector<aiMaterial *> &materials,
unsigned int& defaultMatIdx); unsigned int &defaultMatIdx);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/// Generate a mesh that consists of just a single quad /// Generate a mesh that consists of just a single quad
aiMesh* BuildSingleQuadMesh(const SkyboxVertex& v1, aiMesh *BuildSingleQuadMesh(const SkyboxVertex &v1,
const SkyboxVertex& v2, const SkyboxVertex &v2,
const SkyboxVertex& v3, const SkyboxVertex &v3,
const SkyboxVertex& v4); const SkyboxVertex &v4);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/// Build a sky-box /// Build a sky-box
@ -245,8 +248,8 @@ private:
/// @param meshes Receives 6 output meshes /// @param meshes Receives 6 output meshes
/// @param materials The last 6 materials are assigned to the newly /// @param materials The last 6 materials are assigned to the newly
/// created meshes. The names of the materials are adjusted. /// created meshes. The names of the materials are adjusted.
void BuildSkybox(std::vector<aiMesh*>& meshes, void BuildSkybox(std::vector<aiMesh *> &meshes,
std::vector<aiMaterial*> materials); std::vector<aiMaterial *> materials);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Copy a material for a mesh to the output material list /** Copy a material for a mesh to the output material list
@ -256,10 +259,10 @@ private:
* @param defMatIdx Default material index - UINT_MAX if not present * @param defMatIdx Default material index - UINT_MAX if not present
* @param mesh Mesh to work on * @param mesh Mesh to work on
*/ */
void CopyMaterial(std::vector<aiMaterial*>& materials, void CopyMaterial(std::vector<aiMaterial *> &materials,
std::vector< std::pair<aiMaterial*, unsigned int> >& inmaterials, std::vector<std::pair<aiMaterial *, unsigned int>> &inmaterials,
unsigned int& defMatIdx, unsigned int &defMatIdx,
aiMesh* mesh); aiMesh *mesh);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Compute animations for a specific node /** Compute animations for a specific node
@ -267,8 +270,8 @@ private:
* @param root Node to be processed * @param root Node to be processed
* @param anims The list of output animations * @param anims The list of output animations
*/ */
void ComputeAnimations(Node* root, aiNode* real, void ComputeAnimations(Node *root, aiNode *real,
std::vector<aiNodeAnim*>& anims); std::vector<aiNodeAnim *> &anims);
private: private:
/// Configuration option: desired output FPS /// Configuration option: desired output FPS
@ -276,6 +279,12 @@ private:
/// Configuration option: speed flag was set? /// Configuration option: speed flag was set?
bool configSpeedFlag; bool configSpeedFlag;
std::vector<aiCamera*> cameras;
std::vector<aiLight*> lights;
unsigned int guessedMeshCnt;
unsigned int guessedMatCnt;
unsigned int guessedAnimCnt;
}; };
} // end of namespace Assimp } // end of namespace Assimp

716
code/AssetLib/Irr/IRRMeshLoader.cpp
View File

@ -57,16 +57,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
using namespace Assimp; using namespace Assimp;
static const aiImporterDesc desc = { static const aiImporterDesc desc = {
"Irrlicht Mesh Reader", "Irrlicht Mesh Reader",
"", "",
"", "",
"http://irrlicht.sourceforge.net/", "http://irrlicht.sourceforge.net/",
aiImporterFlags_SupportTextFlavour, aiImporterFlags_SupportTextFlavour,
0, 0,
0, 0,
0, 0,
0, 0,
"xml irrmesh" "xml irrmesh"
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -80,419 +80,443 @@ IRRMeshImporter::~IRRMeshImporter() = default;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file. // Returns whether the class can handle the format of the given file.
bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
/* NOTE: A simple check for the file extension is not enough /* NOTE: A simple check for the file extension is not enough
* here. Irrmesh and irr are easy, but xml is too generic * here. Irrmesh and irr are easy, but xml is too generic
* and could be collada, too. So we need to open the file and * and could be collada, too. So we need to open the file and
* search for typical tokens. * search for typical tokens.
*/ */
static const char *tokens[] = { "irrmesh" }; static const char *tokens[] = { "irrmesh" };
return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Get a list of all file extensions which are handled by this class // Get a list of all file extensions which are handled by this class
const aiImporterDesc *IRRMeshImporter::GetInfo() const { const aiImporterDesc *IRRMeshImporter::GetInfo() const {
return &desc; return &desc;
} }
static void releaseMaterial(aiMaterial **mat) { static void releaseMaterial(aiMaterial **mat) {
if (*mat != nullptr) { if (*mat != nullptr) {
delete *mat; delete *mat;
*mat = nullptr; *mat = nullptr;
} }
} }
static void releaseMesh(aiMesh **mesh) { static void releaseMesh(aiMesh **mesh) {
if (*mesh != nullptr) { if (*mesh != nullptr) {
delete *mesh; delete *mesh;
*mesh = nullptr; *mesh = nullptr;
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. // Imports the given file into the given scene structure.
void IRRMeshImporter::InternReadFile(const std::string &pFile, void IRRMeshImporter::InternReadFile(const std::string &pFile,
aiScene *pScene, IOSystem *pIOHandler) { aiScene *pScene, IOSystem *pIOHandler) {
std::unique_ptr<IOStream> file(pIOHandler->Open(pFile)); std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
// Check whether we can read from the file // Check whether we can read from the file
if (file == nullptr) if (file == nullptr)
throw DeadlyImportError("Failed to open IRRMESH file ", pFile); throw DeadlyImportError("Failed to open IRRMESH file ", pFile);
// Construct the irrXML parser // Construct the irrXML parser
XmlParser parser; XmlParser parser;
if (!parser.parse( file.get() )) { if (!parser.parse(file.get())) {
throw DeadlyImportError("XML parse error while loading IRRMESH file ", pFile); throw DeadlyImportError("XML parse error while loading IRRMESH file ", pFile);
} }
XmlNode root = parser.getRootNode(); XmlNode root = parser.getRootNode();
// final data // final data
std::vector<aiMaterial *> materials; std::vector<aiMaterial *> materials;
std::vector<aiMesh *> meshes; std::vector<aiMesh *> meshes;
materials.reserve(5); materials.reserve(5);
meshes.reserve(5); meshes.reserve(5);
// temporary data - current mesh buffer // temporary data - current mesh buffer
aiMaterial *curMat = nullptr; // TODO move all these to inside loop
aiMesh *curMesh = nullptr; aiMaterial *curMat = nullptr;
unsigned int curMatFlags = 0; aiMesh *curMesh = nullptr;
unsigned int curMatFlags = 0;
std::vector<aiVector3D> curVertices, curNormals, curTangents, curBitangents; std::vector<aiVector3D> curVertices, curNormals, curTangents, curBitangents;
std::vector<aiColor4D> curColors; std::vector<aiColor4D> curColors;
std::vector<aiVector3D> curUVs, curUV2s; std::vector<aiVector3D> curUVs, curUV2s;
// some temporary variables // some temporary variables
int textMeaning = 0; // textMeaning is a 15 year old variable, that could've been an enum
int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents // int textMeaning = 0; // 0=none? 1=vertices 2=indices
bool useColors = false; // int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents
bool useColors = false;
// Parse the XML file /*
for (pugi::xml_node child : root.children()) { ** irrmesh files have a top level <mesh> owning multiple <buffer> nodes.
if (child.type() == pugi::node_element) { ** Each <buffer> contains <material>, <vertices>, and <indices>
if (!ASSIMP_stricmp(child.name(), "buffer") && (curMat || curMesh)) { ** <material> tags here directly owns the material data specs
// end of previous buffer. A material and a mesh should be there ** <vertices> are a vertex per line, contains position, UV1 coords, maybe UV2, normal, tangent, bitangent
if (!curMat || !curMesh) { ** <boundingbox> is ignored, I think assimp recalculates those?
ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material"); */
releaseMaterial(&curMat);
releaseMesh(&curMesh);
} else {
materials.push_back(curMat);
meshes.push_back(curMesh);
}
curMat = nullptr;
curMesh = nullptr;
curVertices.clear(); // Parse the XML file
curColors.clear(); pugi::xml_node const &meshNode = root.child("mesh");
curNormals.clear(); for (pugi::xml_node bufferNode : meshNode.children()) {
curUV2s.clear(); if (ASSIMP_stricmp(bufferNode.name(), "buffer")) {
curUVs.clear(); // Might be a useless warning
curTangents.clear(); ASSIMP_LOG_WARN("IRRMESH: Ignoring non buffer node <", bufferNode.name(), "> in mesh declaration");
curBitangents.clear(); continue;
} }
if (!ASSIMP_stricmp(child.name(), "material")) { curMat = nullptr;
if (curMat) { curMesh = nullptr;
ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please");
releaseMaterial(&curMat);
}
curMat = ParseMaterial(curMatFlags);
}
/* no else here! */ if (!ASSIMP_stricmp(child.name(), "vertices")) {
pugi::xml_attribute attr = child.attribute("vertexCount");
int num = attr.as_int();
//int num = reader->getAttributeValueAsInt("vertexCount");
if (!num) { curVertices.clear();
// This is possible ... remove the mesh from the list and skip further reading curColors.clear();
ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices"); curNormals.clear();
curUV2s.clear();
curUVs.clear();
curTangents.clear();
curBitangents.clear();
releaseMaterial(&curMat); // TODO ensure all three nodes are present and populated
releaseMesh(&curMesh); // before allocating everything
textMeaning = 0;
continue;
}
curVertices.reserve(num); // Get first material node
curNormals.reserve(num); pugi::xml_node materialNode = bufferNode.child("material");
curColors.reserve(num); if (materialNode) {
curUVs.reserve(num); curMat = ParseMaterial(materialNode, curMatFlags);
// Warn if there's more materials
if (materialNode.next_sibling("material")) {
ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please");
}
} else {
ASSIMP_LOG_ERROR("IRRMESH: Buffer must contain one material");
continue;
}
// Determine the file format // Get first vertices node
//const char *t = reader->getAttributeValueSafe("type"); pugi::xml_node verticesNode = bufferNode.child("vertices");
pugi::xml_attribute t = child.attribute("type"); if (verticesNode) {
if (!ASSIMP_stricmp("2tcoords", t.name())) { pugi::xml_attribute vertexCountAttrib = verticesNode.attribute("vertexCount");
curUV2s.reserve(num); int vertexCount = vertexCountAttrib.as_int();
vertexFormat = 1; if (vertexCount == 0) {
// This is possible ... remove the mesh from the list and skip further reading
ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices");
releaseMaterial(&curMat);
// releaseMesh(&curMesh);
continue; // Bail out early
};
if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) { curVertices.reserve(vertexCount);
// ********************************************************* curNormals.reserve(vertexCount);
// We have a second texture! So use this UV channel curColors.reserve(vertexCount);
// for it. The 2nd texture can be either a normal curUVs.reserve(vertexCount);
// texture (solid_2layer or lightmap_xxx) or a normal
// map (normal_..., parallax_...)
// *********************************************************
int idx = 1;
aiMaterial *mat = (aiMaterial *)curMat;
if (curMatFlags & AI_IRRMESH_MAT_lightmap) { VertexFormat vertexFormat;
mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_LIGHTMAP(0)); // Determine the file format
} else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid) { pugi::xml_attribute typeAttrib = verticesNode.attribute("type");
mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0)); if (!ASSIMP_stricmp("2tcoords", typeAttrib.value())) {
} else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) { curUV2s.reserve(vertexCount);
mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(1)); vertexFormat = VertexFormat::t2coord;
} if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) {
} // *********************************************************
} else if (!ASSIMP_stricmp("tangents", t.name())) { // We have a second texture! So use this UV channel
curTangents.reserve(num); // for it. The 2nd texture can be either a normal
curBitangents.reserve(num); // texture (solid_2layer or lightmap_xxx) or a normal
vertexFormat = 2; // map (normal_..., parallax_...)
} else if (ASSIMP_stricmp("standard", t.name())) { // *********************************************************
releaseMaterial(&curMat); int idx = 1;
ASSIMP_LOG_WARN("IRRMESH: Unknown vertex format"); aiMaterial *mat = (aiMaterial *)curMat;
} else
vertexFormat = 0;
textMeaning = 1;
} else if (!ASSIMP_stricmp(child.name(), "indices")) {
if (curVertices.empty() && curMat) {
releaseMaterial(&curMat);
throw DeadlyImportError("IRRMESH: indices must come after vertices");
}
textMeaning = 2; if (curMatFlags & AI_IRRMESH_MAT_lightmap) {
mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_LIGHTMAP(0));
} else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid) {
mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0));
} else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) {
mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(1));
}
}
} else if (!ASSIMP_stricmp("tangents", typeAttrib.value())) {
curTangents.reserve(vertexCount);
curBitangents.reserve(vertexCount);
vertexFormat = VertexFormat::tangent;
} else if (!ASSIMP_stricmp("standard", typeAttrib.value())) {
vertexFormat = VertexFormat::standard;
} else {
// Unsupported format, discard whole buffer/mesh
// Assuming we have a correct material, then release it
// We don't have a correct mesh for sure here
releaseMaterial(&curMat);
ASSIMP_LOG_ERROR("IRRMESH: Unknown vertex format");
continue; // Skip rest of buffer
};
// start a new mesh // We know what format buffer is, collect numbers
curMesh = new aiMesh(); ParseBufferVertices(verticesNode.text().get(), vertexFormat,
curVertices, curNormals,
curTangents, curBitangents,
curUVs, curUV2s, curColors, useColors);
}
// allocate storage for all faces // Get indices
pugi::xml_attribute attr = child.attribute("indexCount"); // At this point we have some vertices and a valid material
curMesh->mNumVertices = attr.as_int(); // Collect indices and create aiMesh at the same time
if (!curMesh->mNumVertices) { pugi::xml_node indicesNode = bufferNode.child("indices");
// This is possible ... remove the mesh from the list and skip further reading if (indicesNode) {
ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices"); // start a new mesh
curMesh = new aiMesh();
// mesh - away // allocate storage for all faces
releaseMesh(&curMesh); pugi::xml_attribute attr = indicesNode.attribute("indexCount");
curMesh->mNumVertices = attr.as_int();
if (!curMesh->mNumVertices) {
// This is possible ... remove the mesh from the list and skip further reading
ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices");
// material - away // mesh - away
releaseMaterial(&curMat); releaseMesh(&curMesh);
textMeaning = 0; // material - away
continue; releaseMaterial(&curMat);
} continue; // Go to next buffer
}
if (curMesh->mNumVertices % 3) { if (curMesh->mNumVertices % 3) {
ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3"); ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3");
} }
curMesh->mNumFaces = curMesh->mNumVertices / 3; curMesh->mNumFaces = curMesh->mNumVertices / 3;
curMesh->mFaces = new aiFace[curMesh->mNumFaces]; curMesh->mFaces = new aiFace[curMesh->mNumFaces];
// setup some members // setup some members
curMesh->mMaterialIndex = (unsigned int)materials.size(); curMesh->mMaterialIndex = (unsigned int)materials.size();
curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
// allocate storage for all vertices // allocate storage for all vertices
curMesh->mVertices = new aiVector3D[curMesh->mNumVertices]; curMesh->mVertices = new aiVector3D[curMesh->mNumVertices];
if (curNormals.size() == curVertices.size()) { if (curNormals.size() == curVertices.size()) {
curMesh->mNormals = new aiVector3D[curMesh->mNumVertices]; curMesh->mNormals = new aiVector3D[curMesh->mNumVertices];
} }
if (curTangents.size() == curVertices.size()) { if (curTangents.size() == curVertices.size()) {
curMesh->mTangents = new aiVector3D[curMesh->mNumVertices]; curMesh->mTangents = new aiVector3D[curMesh->mNumVertices];
} }
if (curBitangents.size() == curVertices.size()) { if (curBitangents.size() == curVertices.size()) {
curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices]; curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices];
} }
if (curColors.size() == curVertices.size() && useColors) { if (curColors.size() == curVertices.size() && useColors) {
curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices]; curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices];
} }
if (curUVs.size() == curVertices.size()) { if (curUVs.size() == curVertices.size()) {
curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices]; curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices];
} }
if (curUV2s.size() == curVertices.size()) { if (curUV2s.size() == curVertices.size()) {
curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices]; curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices];
} }
}
//break;
//case EXN_TEXT: { // read indices
const char *sz = child.child_value(); aiFace *curFace = curMesh->mFaces;
if (textMeaning == 1) { aiFace *const faceEnd = curMesh->mFaces + curMesh->mNumFaces;
textMeaning = 0;
// read vertices aiVector3D *pcV = curMesh->mVertices;
do { aiVector3D *pcN = curMesh->mNormals;
SkipSpacesAndLineEnd(&sz); aiVector3D *pcT = curMesh->mTangents;
aiVector3D temp; aiVector3D *pcB = curMesh->mBitangents;
aiColor4D c; aiColor4D *pcC0 = curMesh->mColors[0];
aiVector3D *pcT0 = curMesh->mTextureCoords[0];
aiVector3D *pcT1 = curMesh->mTextureCoords[1];
// Read the vertex position unsigned int curIdx = 0;
sz = fast_atoreal_move<float>(sz, (float &)temp.x); unsigned int total = 0;
SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float &)temp.y); // NOTE this might explode for UTF-16 and wchars
SkipSpaces(&sz); const char *sz = indicesNode.text().get();
// For each index loop over aiMesh faces
while (SkipSpacesAndLineEnd(&sz)) {
if (curFace >= faceEnd) {
ASSIMP_LOG_ERROR("IRRMESH: Too many indices");
break;
}
// if new face
if (!curIdx) {
curFace->mNumIndices = 3;
curFace->mIndices = new unsigned int[3];
}
sz = fast_atoreal_move<float>(sz, (float &)temp.z); // Read index base 10
SkipSpaces(&sz); // function advances the pointer
curVertices.push_back(temp); unsigned int idx = strtoul10(sz, &sz);
if (idx >= curVertices.size()) {
ASSIMP_LOG_ERROR("IRRMESH: Index out of range");
idx = 0;
}
// Read the vertex normals // make up our own indices?
sz = fast_atoreal_move<float>(sz, (float &)temp.x); curFace->mIndices[curIdx] = total++;
SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float &)temp.y); // Copy over data to aiMesh
SkipSpaces(&sz); *pcV++ = curVertices[idx];
if (pcN) *pcN++ = curNormals[idx];
if (pcT) *pcT++ = curTangents[idx];
if (pcB) *pcB++ = curBitangents[idx];
if (pcC0) *pcC0++ = curColors[idx];
if (pcT0) *pcT0++ = curUVs[idx];
if (pcT1) *pcT1++ = curUV2s[idx];
sz = fast_atoreal_move<float>(sz, (float &)temp.z); // start new face
SkipSpaces(&sz); if (++curIdx == 3) {
curNormals.push_back(temp); ++curFace;
curIdx = 0;
}
}
// We should be at the end of mFaces
if (curFace != faceEnd)
ASSIMP_LOG_ERROR("IRRMESH: Not enough indices");
}
// read the vertex colors // Finish processing the mesh - do some small material workarounds
uint32_t clr = strtoul16(sz, &sz); if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) {
ColorFromARGBPacked(clr, c); // Take the opacity value of the current material
// from the common vertex color alpha
aiMaterial *mat = (aiMaterial *)curMat;
mat->AddProperty(&curColors[0].a, 1, AI_MATKEY_OPACITY);
}
// textMeaning = 2;
if (!curColors.empty() && c != *(curColors.end() - 1)) // end of previous buffer. A material and a mesh should be there
useColors = true; if (!curMat || !curMesh) {
ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
releaseMaterial(&curMat);
releaseMesh(&curMesh);
} else {
materials.push_back(curMat);
meshes.push_back(curMesh);
}
}
curColors.push_back(c); // If one is empty then so is the other
SkipSpaces(&sz); if (materials.empty() || meshes.empty()) {
throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file");
}
// read the first UV coordinate set // now generate the output scene
sz = fast_atoreal_move<float>(sz, (float &)temp.x); pScene->mNumMeshes = (unsigned int)meshes.size();
SkipSpaces(&sz); pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
pScene->mMeshes[i] = meshes[i];
sz = fast_atoreal_move<float>(sz, (float &)temp.y); // clean this value ...
SkipSpaces(&sz); pScene->mMeshes[i]->mNumUVComponents[3] = 0;
temp.z = 0.f; }
temp.y = 1.f - temp.y; // DX to OGL
curUVs.push_back(temp);
// read the (optional) second UV coordinate set pScene->mNumMaterials = (unsigned int)materials.size();
if (vertexFormat == 1) { pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
sz = fast_atoreal_move<float>(sz, (float &)temp.x); ::memcpy(pScene->mMaterials, &materials[0], sizeof(void *) * pScene->mNumMaterials);
SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float &)temp.y); pScene->mRootNode = new aiNode();
temp.y = 1.f - temp.y; // DX to OGL pScene->mRootNode->mName.Set("<IRRMesh>");
curUV2s.push_back(temp); pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
} pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
// read optional tangent and bitangent vectors
else if (vertexFormat == 2) {
// tangents
sz = fast_atoreal_move<float>(sz, (float &)temp.x);
SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float &)temp.z); for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
SkipSpaces(&sz); pScene->mRootNode->mMeshes[i] = i;
};
}
sz = fast_atoreal_move<float>(sz, (float &)temp.y); void IRRMeshImporter::ParseBufferVertices(const char *sz, VertexFormat vertexFormat,
SkipSpaces(&sz); std::vector<aiVector3D> &vertices, std::vector<aiVector3D> &normals,
temp.y *= -1.0f; std::vector<aiVector3D> &tangents, std::vector<aiVector3D> &bitangents,
curTangents.push_back(temp); std::vector<aiVector3D> &UVs, std::vector<aiVector3D> &UV2s,
std::vector<aiColor4D> &colors, bool &useColors) {
// read vertices
do {
SkipSpacesAndLineEnd(&sz);
aiVector3D temp;
aiColor4D c;
// bitangents // Read the vertex position
sz = fast_atoreal_move<float>(sz, (float &)temp.x); sz = fast_atoreal_move<float>(sz, (float &)temp.x);
SkipSpaces(&sz); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float &)temp.z); sz = fast_atoreal_move<float>(sz, (float &)temp.y);
SkipSpaces(&sz); SkipSpaces(&sz);
sz = fast_atoreal_move<float>(sz, (float &)temp.y); sz = fast_atoreal_move<float>(sz, (float &)temp.z);
SkipSpaces(&sz); SkipSpaces(&sz);
temp.y *= -1.0f; vertices.push_back(temp);
curBitangents.push_back(temp);
}
}
/* IMPORTANT: We assume that each vertex is specified in one // Read the vertex normals
line. So we can skip the rest of the line - unknown vertex sz = fast_atoreal_move<float>(sz, (float &)temp.x);
elements are ignored. SkipSpaces(&sz);
*/
while (SkipLine(&sz)); sz = fast_atoreal_move<float>(sz, (float &)temp.y);
} else if (textMeaning == 2) { SkipSpaces(&sz);
textMeaning = 0;
// read indices sz = fast_atoreal_move<float>(sz, (float &)temp.z);
aiFace *curFace = curMesh->mFaces; SkipSpaces(&sz);
aiFace *const faceEnd = curMesh->mFaces + curMesh->mNumFaces; normals.push_back(temp);
aiVector3D *pcV = curMesh->mVertices; // read the vertex colors
aiVector3D *pcN = curMesh->mNormals; uint32_t clr = strtoul16(sz, &sz);
aiVector3D *pcT = curMesh->mTangents; ColorFromARGBPacked(clr, c);
aiVector3D *pcB = curMesh->mBitangents;
aiColor4D *pcC0 = curMesh->mColors[0];
aiVector3D *pcT0 = curMesh->mTextureCoords[0];
aiVector3D *pcT1 = curMesh->mTextureCoords[1];
unsigned int curIdx = 0; // If we're pushing more than one distinct color
unsigned int total = 0; if (!colors.empty() && c != *(colors.end() - 1))
while (SkipSpacesAndLineEnd(&sz)) { useColors = true;
if (curFace >= faceEnd) {
ASSIMP_LOG_ERROR("IRRMESH: Too many indices");
break;
}
if (!curIdx) {
curFace->mNumIndices = 3;
curFace->mIndices = new unsigned int[3];
}
unsigned int idx = strtoul10(sz, &sz); colors.push_back(c);
if (idx >= curVertices.size()) { SkipSpaces(&sz);
ASSIMP_LOG_ERROR("IRRMESH: Index out of range");
idx = 0;
}
curFace->mIndices[curIdx] = total++; // read the first UV coordinate set
sz = fast_atoreal_move<float>(sz, (float &)temp.x);
SkipSpaces(&sz);
*pcV++ = curVertices[idx]; sz = fast_atoreal_move<float>(sz, (float &)temp.y);
if (pcN) *pcN++ = curNormals[idx]; SkipSpaces(&sz);
if (pcT) *pcT++ = curTangents[idx]; temp.z = 0.f;
if (pcB) *pcB++ = curBitangents[idx]; temp.y = 1.f - temp.y; // DX to OGL
if (pcC0) *pcC0++ = curColors[idx]; UVs.push_back(temp);
if (pcT0) *pcT0++ = curUVs[idx];
if (pcT1) *pcT1++ = curUV2s[idx];
if (++curIdx == 3) { // NOTE these correspond to specific S3DVertex* structs in irr sourcecode
++curFace; // So by definition, all buffers have either UV2 or tangents or neither
curIdx = 0; // read the (optional) second UV coordinate set
} if (vertexFormat == VertexFormat::t2coord) {
} sz = fast_atoreal_move<float>(sz, (float &)temp.x);
SkipSpaces(&sz);
if (curFace != faceEnd) sz = fast_atoreal_move<float>(sz, (float &)temp.y);
ASSIMP_LOG_ERROR("IRRMESH: Not enough indices"); temp.y = 1.f - temp.y; // DX to OGL
UV2s.push_back(temp);
}
// read optional tangent and bitangent vectors
else if (vertexFormat == VertexFormat::tangent) {
// tangents
sz = fast_atoreal_move<float>(sz, (float &)temp.x);
SkipSpaces(&sz);
// Finish processing the mesh - do some small material workarounds sz = fast_atoreal_move<float>(sz, (float &)temp.z);
if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) { SkipSpaces(&sz);
// Take the opacity value of the current material
// from the common vertex color alpha
aiMaterial *mat = (aiMaterial *)curMat;
mat->AddProperty(&curColors[0].a, 1, AI_MATKEY_OPACITY);
}
}
}
}
// End of the last buffer. A material and a mesh should be there sz = fast_atoreal_move<float>(sz, (float &)temp.y);
if (curMat || curMesh) { SkipSpaces(&sz);
if (!curMat || !curMesh) { temp.y *= -1.0f;
ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material"); tangents.push_back(temp);
releaseMaterial(&curMat);
releaseMesh(&curMesh);
} else {
materials.push_back(curMat);
meshes.push_back(curMesh);
}
}
if (materials.empty()) { // bitangents
throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file"); sz = fast_atoreal_move<float>(sz, (float &)temp.x);
} SkipSpaces(&sz);
// now generate the output scene sz = fast_atoreal_move<float>(sz, (float &)temp.z);
pScene->mNumMeshes = (unsigned int)meshes.size(); SkipSpaces(&sz);
pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
pScene->mMeshes[i] = meshes[i];
// clean this value ... sz = fast_atoreal_move<float>(sz, (float &)temp.y);
pScene->mMeshes[i]->mNumUVComponents[3] = 0; SkipSpaces(&sz);
} temp.y *= -1.0f;
bitangents.push_back(temp);
pScene->mNumMaterials = (unsigned int)materials.size(); }
pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]; } while (SkipLine(&sz));
::memcpy(pScene->mMaterials, &materials[0], sizeof(void *) * pScene->mNumMaterials); /* IMPORTANT: We assume that each vertex is specified in one
line. So we can skip the rest of the line - unknown vertex
pScene->mRootNode = new aiNode(); elements are ignored.
pScene->mRootNode->mName.Set("<IRRMesh>"); */
pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
pScene->mRootNode->mMeshes[i] = i;
}
} }
#endif // !! ASSIMP_BUILD_NO_IRRMESH_IMPORTER #endif // !! ASSIMP_BUILD_NO_IRRMESH_IMPORTER

13
code/AssetLib/Irr/IRRMeshLoader.h
View File

@ -85,6 +85,19 @@ protected:
*/ */
void InternReadFile(const std::string &pFile, aiScene *pScene, void InternReadFile(const std::string &pFile, aiScene *pScene,
IOSystem *pIOHandler) override; IOSystem *pIOHandler) override;
private:
enum class VertexFormat {
standard = 0, // "standard" - also noted as 'normal' format elsewhere
t2coord = 1, // "2tcoord" - standard + 2 UV maps
tangent = 2, // "tangents" - standard + tangents and bitangents
};
void ParseBufferVertices(const char *sz, VertexFormat vertexFormat,
std::vector<aiVector3D> &vertices, std::vector<aiVector3D> &normals,
std::vector<aiVector3D> &tangents, std::vector<aiVector3D> &bitangents,
std::vector<aiVector3D> &UVs, std::vector<aiVector3D> &UV2s,
std::vector<aiColor4D> &colors, bool &useColors);
}; };
} // end of namespace Assimp } // end of namespace Assimp

414
code/AssetLib/Irr/IRRShared.cpp
View File

@ -43,302 +43,302 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* @brief Shared utilities for the IRR and IRRMESH loaders * @brief Shared utilities for the IRR and IRRMESH loaders
*/ */
//This section should be excluded only if both the Irrlicht AND the Irrlicht Mesh importers were omitted. // This section should be excluded only if both the Irrlicht AND the Irrlicht Mesh importers were omitted.
#if !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER)) #if !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER))
#include "IRRShared.h" #include "IRRShared.h"
#include <assimp/ParsingUtils.h> #include <assimp/ParsingUtils.h>
#include <assimp/fast_atof.h> #include <assimp/fast_atof.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/material.h> #include <assimp/material.h>
#include <assimp/DefaultLogger.hpp>
using namespace Assimp; using namespace Assimp;
// Transformation matrix to convert from Assimp to IRR space // Transformation matrix to convert from Assimp to IRR space
const aiMatrix4x4 Assimp::AI_TO_IRR_MATRIX = aiMatrix4x4 ( const aiMatrix4x4 Assimp::AI_TO_IRR_MATRIX = aiMatrix4x4(
1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f); 0.0f, 0.0f, 0.0f, 1.0f);
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// read a property in hexadecimal format (i.e. ffffffff) // read a property in hexadecimal format (i.e. ffffffff)
void IrrlichtBase::ReadHexProperty(HexProperty &out ) { void IrrlichtBase::ReadHexProperty(HexProperty &out, pugi::xml_node& hexnode) {
for (pugi::xml_attribute attrib : mNode->attributes()) { for (pugi::xml_attribute attrib : hexnode.attributes()) {
if (!ASSIMP_stricmp(attrib.name(), "name")) { if (!ASSIMP_stricmp(attrib.name(), "name")) {
out.name = std::string( attrib.value() ); out.name = std::string(attrib.value());
} else if (!ASSIMP_stricmp(attrib.name(),"value")) { } else if (!ASSIMP_stricmp(attrib.name(), "value")) {
// parse the hexadecimal value // parse the hexadecimal value
out.value = strtoul16(attrib.name()); out.value = strtoul16(attrib.value());
} }
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// read a decimal property // read a decimal property
void IrrlichtBase::ReadIntProperty(IntProperty & out) { void IrrlichtBase::ReadIntProperty(IntProperty &out, pugi::xml_node& intnode) {
for (pugi::xml_attribute attrib : mNode->attributes()) { for (pugi::xml_attribute attrib : intnode.attributes()) {
if (!ASSIMP_stricmp(attrib.name(), "name")) { if (!ASSIMP_stricmp(attrib.name(), "name")) {
out.name = std::string(attrib.value()); out.name = std::string(attrib.value());
} else if (!ASSIMP_stricmp(attrib.value(),"value")) { } else if (!ASSIMP_stricmp(attrib.name(), "value")) {
// parse the int value // parse the int value
out.value = strtol10(attrib.name()); out.value = strtol10(attrib.value());
} }
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// read a string property // read a string property
void IrrlichtBase::ReadStringProperty( StringProperty& out) { void IrrlichtBase::ReadStringProperty(StringProperty &out, pugi::xml_node& stringnode) {
for (pugi::xml_attribute attrib : mNode->attributes()) { for (pugi::xml_attribute attrib : stringnode.attributes()) {
if (!ASSIMP_stricmp(attrib.name(), "name")) { if (!ASSIMP_stricmp(attrib.name(), "name")) {
out.name = std::string(attrib.value()); out.name = std::string(attrib.value());
} else if (!ASSIMP_stricmp(attrib.name(), "value")) { } else if (!ASSIMP_stricmp(attrib.name(), "value")) {
// simple copy the string // simple copy the string
out.value = std::string(attrib.value()); out.value = std::string(attrib.value());
} }
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// read a boolean property // read a boolean property
void IrrlichtBase::ReadBoolProperty(BoolProperty &out) { void IrrlichtBase::ReadBoolProperty(BoolProperty &out, pugi::xml_node& boolnode) {
for (pugi::xml_attribute attrib : mNode->attributes()) { for (pugi::xml_attribute attrib : boolnode.attributes()) {
if (!ASSIMP_stricmp(attrib.name(), "name")){ if (!ASSIMP_stricmp(attrib.name(), "name")) {
out.name = std::string(attrib.value()); out.name = std::string(attrib.value());
} else if (!ASSIMP_stricmp(attrib.name(), "value")) { } else if (!ASSIMP_stricmp(attrib.name(), "value")) {
// true or false, case insensitive // true or false, case insensitive
out.value = (ASSIMP_stricmp(attrib.value(), "true") ? false : true); out.value = (ASSIMP_stricmp(attrib.value(), "true") ? false : true);
} }
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// read a float property // read a float property
void IrrlichtBase::ReadFloatProperty(FloatProperty &out) { void IrrlichtBase::ReadFloatProperty(FloatProperty &out, pugi::xml_node &floatnode) {
for (pugi::xml_attribute attrib : mNode->attributes()) { for (pugi::xml_attribute attrib : floatnode.attributes()) {
if (!ASSIMP_stricmp(attrib.name(), "name")) { if (!ASSIMP_stricmp(attrib.name(), "name")) {
out.name = std::string(attrib.value()); out.name = std::string(attrib.value());
} else if (!ASSIMP_stricmp(attrib.name(), "value")) { } else if (!ASSIMP_stricmp(attrib.name(), "value")) {
// just parse the float // just parse the float
out.value = fast_atof(attrib.value()); out.value = fast_atof(attrib.value());
} }
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// read a vector property // read a vector property
void IrrlichtBase::ReadVectorProperty( VectorProperty &out ) { void IrrlichtBase::ReadVectorProperty(VectorProperty &out, pugi::xml_node& vectornode) {
for (pugi::xml_attribute attrib : mNode->attributes()) { for (pugi::xml_attribute attrib : vectornode.attributes()) {
if (!ASSIMP_stricmp(attrib.name(), "name")) { if (!ASSIMP_stricmp(attrib.name(), "name")) {
out.name = std::string(attrib.value()); out.name = std::string(attrib.value());
} else if (!ASSIMP_stricmp(attrib.name(), "value")) { } else if (!ASSIMP_stricmp(attrib.name(), "value")) {
// three floats, separated with commas // three floats, separated with commas
const char *ptr = attrib.value(); const char *ptr = attrib.value();
SkipSpaces(&ptr); SkipSpaces(&ptr);
ptr = fast_atoreal_move<float>( ptr,(float&)out.value.x ); ptr = fast_atoreal_move<float>(ptr, (float &)out.value.x);
SkipSpaces(&ptr); SkipSpaces(&ptr);
if (',' != *ptr) { if (',' != *ptr) {
ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition"); ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
} else { } else {
SkipSpaces(ptr + 1, &ptr); SkipSpaces(ptr + 1, &ptr);
} }
ptr = fast_atoreal_move<float>( ptr,(float&)out.value.y ); ptr = fast_atoreal_move<float>(ptr, (float &)out.value.y);
SkipSpaces(&ptr); SkipSpaces(&ptr);
if (',' != *ptr) { if (',' != *ptr) {
ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition"); ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
} else { } else {
SkipSpaces(ptr + 1, &ptr); SkipSpaces(ptr + 1, &ptr);
} }
ptr = fast_atoreal_move<float>( ptr,(float&)out.value.z ); ptr = fast_atoreal_move<float>(ptr, (float &)out.value.z);
} }
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Convert a string to a proper aiMappingMode // Convert a string to a proper aiMappingMode
int ConvertMappingMode(const std::string& mode) { int ConvertMappingMode(const std::string &mode) {
if (mode == "texture_clamp_repeat") { if (mode == "texture_clamp_repeat") {
return aiTextureMapMode_Wrap; return aiTextureMapMode_Wrap;
} else if (mode == "texture_clamp_mirror") { } else if (mode == "texture_clamp_mirror") {
return aiTextureMapMode_Mirror; return aiTextureMapMode_Mirror;
} }
return aiTextureMapMode_Clamp; return aiTextureMapMode_Clamp;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Parse a material from the XML file // Parse a material from the XML file
aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags) { aiMaterial *IrrlichtBase::ParseMaterial(pugi::xml_node& materialNode, unsigned int &matFlags) {
aiMaterial* mat = new aiMaterial(); aiMaterial *mat = new aiMaterial();
aiColor4D clr; aiColor4D clr;
aiString s; aiString s;
matFlags = 0; // zero output flags matFlags = 0; // zero output flags
int cnt = 0; // number of used texture channels int cnt = 0; // number of used texture channels
unsigned int nd = 0; unsigned int nd = 0;
for (pugi::xml_node child : mNode->children()) { for (pugi::xml_node child : materialNode.children()) {
if (!ASSIMP_stricmp(child.name(), "color")) { // Hex properties if (!ASSIMP_stricmp(child.name(), "color")) { // Hex properties
HexProperty prop; HexProperty prop;
ReadHexProperty(prop); ReadHexProperty(prop, child);
if (prop.name == "Diffuse") { if (prop.name == "Diffuse") {
ColorFromARGBPacked(prop.value, clr); ColorFromARGBPacked(prop.value, clr);
mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
} else if (prop.name == "Ambient") { } else if (prop.name == "Ambient") {
ColorFromARGBPacked(prop.value, clr); ColorFromARGBPacked(prop.value, clr);
mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT); mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
} else if (prop.name == "Specular") { } else if (prop.name == "Specular") {
ColorFromARGBPacked(prop.value, clr); ColorFromARGBPacked(prop.value, clr);
mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR); mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
} }
// NOTE: The 'emissive' property causes problems. It is // NOTE: The 'emissive' property causes problems. It is
// often != 0, even if there is obviously no light // often != 0, even if there is obviously no light
// emitted by the described surface. In fact I think // emitted by the described surface. In fact I think
// IRRLICHT ignores this property, too. // IRRLICHT ignores this property, too.
#if 0 #if 0
else if (prop.name == "Emissive") { else if (prop.name == "Emissive") {
ColorFromARGBPacked(prop.value,clr); ColorFromARGBPacked(prop.value,clr);
mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE); mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
} }
#endif #endif
} else if (!ASSIMP_stricmp(child.name(), "float")) { // Float properties } else if (!ASSIMP_stricmp(child.name(), "float")) { // Float properties
FloatProperty prop; FloatProperty prop;
ReadFloatProperty(prop); ReadFloatProperty(prop, child);
if (prop.name == "Shininess") { if (prop.name == "Shininess") {
mat->AddProperty(&prop.value, 1, AI_MATKEY_SHININESS); mat->AddProperty(&prop.value, 1, AI_MATKEY_SHININESS);
} }
} else if (!ASSIMP_stricmp(child.name(), "bool")) { // Bool properties } else if (!ASSIMP_stricmp(child.name(), "bool")) { // Bool properties
BoolProperty prop; BoolProperty prop;
ReadBoolProperty(prop); ReadBoolProperty(prop, child);
if (prop.name == "Wireframe") { if (prop.name == "Wireframe") {
int val = (prop.value ? true : false); int val = (prop.value ? true : false);
mat->AddProperty(&val, 1, AI_MATKEY_ENABLE_WIREFRAME); mat->AddProperty(&val, 1, AI_MATKEY_ENABLE_WIREFRAME);
} else if (prop.name == "GouraudShading") { } else if (prop.name == "GouraudShading") {
int val = (prop.value ? aiShadingMode_Gouraud : aiShadingMode_NoShading); int val = (prop.value ? aiShadingMode_Gouraud : aiShadingMode_NoShading);
mat->AddProperty(&val, 1, AI_MATKEY_SHADING_MODEL); mat->AddProperty(&val, 1, AI_MATKEY_SHADING_MODEL);
} else if (prop.name == "BackfaceCulling") { } else if (prop.name == "BackfaceCulling") {
int val = (!prop.value); int val = (!prop.value);
mat->AddProperty(&val, 1, AI_MATKEY_TWOSIDED); mat->AddProperty(&val, 1, AI_MATKEY_TWOSIDED);
} }
} else if (!ASSIMP_stricmp(child.name(), "texture") || } else if (!ASSIMP_stricmp(child.name(), "texture") ||
!ASSIMP_stricmp(child.name(), "enum")) { // String properties - textures and texture related properties !ASSIMP_stricmp(child.name(), "enum")) { // String properties - textures and texture related properties
StringProperty prop; StringProperty prop;
ReadStringProperty(prop); ReadStringProperty(prop, child);
if (prop.value.length()) { if (prop.value.length()) {
// material type (shader) // material type (shader)
if (prop.name == "Type") { if (prop.name == "Type") {
if (prop.value == "solid") { if (prop.value == "solid") {
// default material ... // default material ...
} else if (prop.value == "trans_vertex_alpha") { } else if (prop.value == "trans_vertex_alpha") {
matFlags = AI_IRRMESH_MAT_trans_vertex_alpha; matFlags = AI_IRRMESH_MAT_trans_vertex_alpha;
} else if (prop.value == "lightmap") { } else if (prop.value == "lightmap") {
matFlags = AI_IRRMESH_MAT_lightmap; matFlags = AI_IRRMESH_MAT_lightmap;
} else if (prop.value == "solid_2layer") { } else if (prop.value == "solid_2layer") {
matFlags = AI_IRRMESH_MAT_solid_2layer; matFlags = AI_IRRMESH_MAT_solid_2layer;
} else if (prop.value == "lightmap_m2") { } else if (prop.value == "lightmap_m2") {
matFlags = AI_IRRMESH_MAT_lightmap_m2; matFlags = AI_IRRMESH_MAT_lightmap_m2;
} else if (prop.value == "lightmap_m4") { } else if (prop.value == "lightmap_m4") {
matFlags = AI_IRRMESH_MAT_lightmap_m4; matFlags = AI_IRRMESH_MAT_lightmap_m4;
} else if (prop.value == "lightmap_light") { } else if (prop.value == "lightmap_light") {
matFlags = AI_IRRMESH_MAT_lightmap_light; matFlags = AI_IRRMESH_MAT_lightmap_light;
} else if (prop.value == "lightmap_light_m2") { } else if (prop.value == "lightmap_light_m2") {
matFlags = AI_IRRMESH_MAT_lightmap_light_m2; matFlags = AI_IRRMESH_MAT_lightmap_light_m2;
} else if (prop.value == "lightmap_light_m4") { } else if (prop.value == "lightmap_light_m4") {
matFlags = AI_IRRMESH_MAT_lightmap_light_m4; matFlags = AI_IRRMESH_MAT_lightmap_light_m4;
} else if (prop.value == "lightmap_add") { } else if (prop.value == "lightmap_add") {
matFlags = AI_IRRMESH_MAT_lightmap_add; matFlags = AI_IRRMESH_MAT_lightmap_add;
} else if (prop.value == "normalmap_solid" || } else if (prop.value == "normalmap_solid" ||
prop.value == "parallaxmap_solid") { // Normal and parallax maps are treated equally prop.value == "parallaxmap_solid") { // Normal and parallax maps are treated equally
matFlags = AI_IRRMESH_MAT_normalmap_solid; matFlags = AI_IRRMESH_MAT_normalmap_solid;
} else if (prop.value == "normalmap_trans_vertex_alpha" || } else if (prop.value == "normalmap_trans_vertex_alpha" ||
prop.value == "parallaxmap_trans_vertex_alpha") { prop.value == "parallaxmap_trans_vertex_alpha") {
matFlags = AI_IRRMESH_MAT_normalmap_tva; matFlags = AI_IRRMESH_MAT_normalmap_tva;
} else if (prop.value == "normalmap_trans_add" || } else if (prop.value == "normalmap_trans_add" ||
prop.value == "parallaxmap_trans_add") { prop.value == "parallaxmap_trans_add") {
matFlags = AI_IRRMESH_MAT_normalmap_ta; matFlags = AI_IRRMESH_MAT_normalmap_ta;
} else { } else {
ASSIMP_LOG_WARN("IRRMat: Unrecognized material type: ", prop.value); ASSIMP_LOG_WARN("IRRMat: Unrecognized material type: ", prop.value);
} }
} }
// Up to 4 texture channels are supported // Up to 4 texture channels are supported
if (prop.name == "Texture1") { if (prop.name == "Texture1") {
// Always accept the primary texture channel // Always accept the primary texture channel
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0)); mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
} else if (prop.name == "Texture2" && cnt == 1) { } else if (prop.name == "Texture2" && cnt == 1) {
// 2-layer material lightmapped? // 2-layer material lightmapped?
if (matFlags & AI_IRRMESH_MAT_lightmap) { if (matFlags & AI_IRRMESH_MAT_lightmap) {
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s, AI_MATKEY_TEXTURE_LIGHTMAP(0)); mat->AddProperty(&s, AI_MATKEY_TEXTURE_LIGHTMAP(0));
// set the corresponding material flag // set the corresponding material flag
matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
} else if (matFlags & AI_IRRMESH_MAT_normalmap_solid) { // alternatively: normal or parallax mapping } else if (matFlags & AI_IRRMESH_MAT_normalmap_solid) { // alternatively: normal or parallax mapping
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s, AI_MATKEY_TEXTURE_NORMALS(0)); mat->AddProperty(&s, AI_MATKEY_TEXTURE_NORMALS(0));
// set the corresponding material flag // set the corresponding material flag
matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
} else if (matFlags & AI_IRRMESH_MAT_solid_2layer) { // or just as second diffuse texture } else if (matFlags & AI_IRRMESH_MAT_solid_2layer) { // or just as second diffuse texture
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(1)); mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(1));
++nd; ++nd;
// set the corresponding material flag // set the corresponding material flag
matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
} else { } else {
ASSIMP_LOG_WARN("IRRmat: Skipping second texture"); ASSIMP_LOG_WARN("IRRmat: Skipping second texture");
} }
} else if (prop.name == "Texture3" && cnt == 2) { } else if (prop.name == "Texture3" && cnt == 2) {
// Irrlicht does not seem to use these channels. // Irrlicht does not seem to use these channels.
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 1)); mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 1));
} else if (prop.name == "Texture4" && cnt == 3) { } else if (prop.name == "Texture4" && cnt == 3) {
// Irrlicht does not seem to use these channels. // Irrlicht does not seem to use these channels.
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 2)); mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 2));
} }
// Texture mapping options // Texture mapping options
if (prop.name == "TextureWrap1" && cnt >= 1) { if (prop.name == "TextureWrap1" && cnt >= 1) {
int map = ConvertMappingMode(prop.value); int map = ConvertMappingMode(prop.value);
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
} else if (prop.name == "TextureWrap2" && cnt >= 2) { } else if (prop.name == "TextureWrap2" && cnt >= 2) {
int map = ConvertMappingMode(prop.value); int map = ConvertMappingMode(prop.value);
if (matFlags & AI_IRRMESH_MAT_lightmap) { if (matFlags & AI_IRRMESH_MAT_lightmap) {
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(0)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(0));
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(0)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(0));
} else if (matFlags & (AI_IRRMESH_MAT_normalmap_solid)) { } else if (matFlags & (AI_IRRMESH_MAT_normalmap_solid)) {
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_NORMALS(0)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_NORMALS(0));
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_NORMALS(0)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_NORMALS(0));
} else if (matFlags & AI_IRRMESH_MAT_solid_2layer) { } else if (matFlags & AI_IRRMESH_MAT_solid_2layer) {
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1));
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1));
} }
} else if (prop.name == "TextureWrap3" && cnt >= 3) { } else if (prop.name == "TextureWrap3" && cnt >= 3) {
int map = ConvertMappingMode(prop.value); int map = ConvertMappingMode(prop.value);
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 1)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 1));
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 1)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 1));
} else if (prop.name == "TextureWrap4" && cnt >= 4) { } else if (prop.name == "TextureWrap4" && cnt >= 4) {
int map = ConvertMappingMode(prop.value); int map = ConvertMappingMode(prop.value);
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 2)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 2));
mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 2)); mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 2));
} }
} }
} }
//break; // break;
/*case EXN_ELEMENT_END: /*case EXN_ELEMENT_END:
// Assume there are no further nested nodes in <material> elements // Assume there are no further nested nodes in <material> elements
if ( !ASSIMP_stricmp(reader->getNodeName(),"material") || if ( !ASSIMP_stricmp(reader->getNodeName(),"material") ||
@ -378,8 +378,8 @@ aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags) {
break; break;
} }
}*/ }*/
} }
ASSIMP_LOG_ERROR("IRRMESH: Unexpected end of file. Material is not complete"); //ASSIMP_LOG_ERROR("IRRMESH: Unexpected end of file. Material is not complete");
return mat; return mat;
} }

23
code/AssetLib/Irr/IRRShared.h
View File

@ -1,8 +1,8 @@
/** @file IRRShared.h /** @file IRRShared.h
* @brief Shared utilities for the IRR and IRRMESH loaders * @brief Shared utilities for the IRR and IRRMESH loaders
*/ */
#ifndef INCLUDED_AI_IRRSHARED_H #ifndef INCLUDED_AI_IRRSHARED_H
#define INCLUDED_AI_IRRSHARED_H #define INCLUDED_AI_IRRSHARED_H
@ -58,8 +58,7 @@ extern const aiMatrix4x4 AI_TO_IRR_MATRIX;
*/ */
class IrrlichtBase { class IrrlichtBase {
protected: protected:
IrrlichtBase() : IrrlichtBase() {
mNode(nullptr) {
// empty // empty
} }
@ -82,25 +81,25 @@ protected:
/// XML reader instance /// XML reader instance
XmlParser mParser; XmlParser mParser;
pugi::xml_node *mNode;
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Parse a material description from the XML /** Parse a material description from the XML
* @return The created material * @return The created material
* @param matFlags Receives AI_IRRMESH_MAT_XX flags * @param matFlags Receives AI_IRRMESH_MAT_XX flags
*/ */
aiMaterial *ParseMaterial(unsigned int &matFlags); aiMaterial *ParseMaterial(pugi::xml_node &materialNode, unsigned int &matFlags);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Read a property of the specified type from the current XML element. /** Read a property of the specified type from the current XML element.
* @param out Receives output data * @param out Receives output data
* @param node XML attribute element containing data
*/ */
void ReadHexProperty(HexProperty &out); void ReadHexProperty(HexProperty &out, pugi::xml_node& hexnode);
void ReadStringProperty(StringProperty &out); void ReadStringProperty(StringProperty &out, pugi::xml_node& stringnode);
void ReadBoolProperty(BoolProperty &out); void ReadBoolProperty(BoolProperty &out, pugi::xml_node& boolnode);
void ReadFloatProperty(FloatProperty &out); void ReadFloatProperty(FloatProperty &out, pugi::xml_node& floatnode);
void ReadVectorProperty(VectorProperty &out); void ReadVectorProperty(VectorProperty &out, pugi::xml_node& vectornode);
void ReadIntProperty(IntProperty &out); void ReadIntProperty(IntProperty &out, pugi::xml_node& intnode);
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

21
code/AssetLib/LWS/LWSLoader.cpp
View File

@ -632,18 +632,17 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
nodes.push_back(d); nodes.push_back(d);
} }
ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Channel\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Channel\'");
} else {
// important: index of channel
nodes.back().channels.emplace_back();
LWO::Envelope &env = nodes.back().channels.back();
env.index = strtoul10(c);
// currently we can just interpret the standard channels 0...9
// (hack) assume that index-i yields the binary channel type from LWO
env.type = (LWO::EnvelopeType)(env.index + 1);
} }
// important: index of channel
nodes.back().channels.emplace_back();
LWO::Envelope &env = nodes.back().channels.back();
env.index = strtoul10(c);
// currently we can just interpret the standard channels 0...9
// (hack) assume that index-i yields the binary channel type from LWO
env.type = (LWO::EnvelopeType)(env.index + 1);
} }
// 'Envelope': a single animation channel // 'Envelope': a single animation channel
else if ((*it).tokens[0] == "Envelope") { else if ((*it).tokens[0] == "Envelope") {

39
code/AssetLib/MD5/MD5Parser.cpp
View File

@ -138,18 +138,31 @@ bool MD5Parser::ParseSection(Section &out) {
char *sz = buffer; char *sz = buffer;
while (!IsSpaceOrNewLine(*buffer)) { while (!IsSpaceOrNewLine(*buffer)) {
++buffer; ++buffer;
if (buffer == bufferEnd)
return false;
} }
out.mName = std::string(sz, (uintptr_t)(buffer - sz)); out.mName = std::string(sz, (uintptr_t)(buffer - sz));
SkipSpaces(); while (IsSpace(*buffer)) {
++buffer;
if (buffer == bufferEnd)
return false;
}
bool running = true; bool running = true;
while (running) { while (running) {
if ('{' == *buffer) { if ('{' == *buffer) {
// it is a normal section so read all lines // it is a normal section so read all lines
++buffer; ++buffer;
if (buffer == bufferEnd)
return false;
bool run = true; bool run = true;
while (run) { while (run) {
if (!SkipSpacesAndLineEnd()) { while (IsSpaceOrNewLine(*buffer)) {
++buffer;
if (buffer == bufferEnd)
return false;
}
if ('\0' == *buffer) {
return false; // seems this was the last section return false; // seems this was the last section
} }
if ('}' == *buffer) { if ('}' == *buffer) {
@ -164,25 +177,39 @@ bool MD5Parser::ParseSection(Section &out) {
elem.szStart = buffer; elem.szStart = buffer;
// terminate the line with zero // terminate the line with zero
while (!IsLineEnd(*buffer)) while (!IsLineEnd(*buffer)) {
++buffer; ++buffer;
if (buffer == bufferEnd)
return false;
}
if (*buffer) { if (*buffer) {
++lineNumber; ++lineNumber;
*buffer++ = '\0'; *buffer++ = '\0';
if (buffer == bufferEnd)
return false;
} }
} }
break; break;
} else if (!IsSpaceOrNewLine(*buffer)) { } else if (!IsSpaceOrNewLine(*buffer)) {
// it is an element at global scope. Parse its value and go on // it is an element at global scope. Parse its value and go on
sz = buffer; sz = buffer;
while (!IsSpaceOrNewLine(*buffer++)) while (!IsSpaceOrNewLine(*buffer++)) {
; if (buffer == bufferEnd)
return false;
}
out.mGlobalValue = std::string(sz, (uintptr_t)(buffer - sz)); out.mGlobalValue = std::string(sz, (uintptr_t)(buffer - sz));
continue; continue;
} }
break; break;
} }
return SkipSpacesAndLineEnd(); if (buffer == bufferEnd)
return false;
while (IsSpaceOrNewLine(*buffer)) {
++buffer;
if (buffer == bufferEnd)
return false;
}
return '\0' != *buffer;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

8
code/AssetLib/MDL/MDLMaterialLoader.cpp
View File

@ -481,6 +481,8 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
pcNew->achFormatHint[2] = 's'; pcNew->achFormatHint[2] = 's';
pcNew->achFormatHint[3] = '\0'; pcNew->achFormatHint[3] = '\0';
SizeCheck(szCurrent + pcNew->mWidth);
pcNew->pcData = (aiTexel *)new unsigned char[pcNew->mWidth]; pcNew->pcData = (aiTexel *)new unsigned char[pcNew->mWidth];
memcpy(pcNew->pcData, szCurrent, pcNew->mWidth); memcpy(pcNew->pcData, szCurrent, pcNew->mWidth);
szCurrent += iWidth; szCurrent += iWidth;
@ -493,12 +495,12 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
aiString szFile; aiString szFile;
const size_t iLen = strlen((const char *)szCurrent); const size_t iLen = strlen((const char *)szCurrent);
size_t iLen2 = iLen + 1; size_t iLen2 = iLen > (MAXLEN - 1) ? (MAXLEN - 1) : iLen;
iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2;
memcpy(szFile.data, (const char *)szCurrent, iLen2); memcpy(szFile.data, (const char *)szCurrent, iLen2);
szFile.data[iLen2] = '\0';
szFile.length = static_cast<ai_uint32>(iLen2); szFile.length = static_cast<ai_uint32>(iLen2);
szCurrent += iLen2; szCurrent += iLen2 + 1;
// place this as diffuse texture // place this as diffuse texture
pcMatOut->AddProperty(&szFile, AI_MATKEY_TEXTURE_DIFFUSE(0)); pcMatOut->AddProperty(&szFile, AI_MATKEY_TEXTURE_DIFFUSE(0));

2
code/AssetLib/Obj/ObjFileData.h
View File

@ -239,8 +239,6 @@ struct Mesh {
unsigned int m_uiMaterialIndex; unsigned int m_uiMaterialIndex;
/// True, if normals are stored. /// True, if normals are stored.
bool m_hasNormals; bool m_hasNormals;
/// True, if vertex colors are stored.
bool m_hasVertexColors;
/// Constructor /// Constructor
explicit Mesh(const std::string &name) : explicit Mesh(const std::string &name) :

5
code/AssetLib/Obj/ObjFileMtlImporter.cpp
View File

@ -252,9 +252,9 @@ void ObjFileMtlImporter::load() {
case 'a': // Anisotropy case 'a': // Anisotropy
{ {
++m_DataIt; ++m_DataIt;
getFloatValue(m_pModel->mCurrentMaterial->anisotropy);
if (m_pModel->mCurrentMaterial != nullptr) if (m_pModel->mCurrentMaterial != nullptr)
m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); getFloatValue(m_pModel->mCurrentMaterial->anisotropy);
m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
} break; } break;
default: { default: {
@ -371,6 +371,7 @@ void ObjFileMtlImporter::getTexture() {
if (m_pModel->mCurrentMaterial == nullptr) { if (m_pModel->mCurrentMaterial == nullptr) {
m_pModel->mCurrentMaterial = new ObjFile::Material(); m_pModel->mCurrentMaterial = new ObjFile::Material();
m_pModel->mCurrentMaterial->MaterialName.Set("Empty_Material"); m_pModel->mCurrentMaterial->MaterialName.Set("Empty_Material");
m_pModel->mMaterialMap["Empty_Material"] = m_pModel->mCurrentMaterial;
} }
const char *pPtr(&(*m_DataIt)); const char *pPtr(&(*m_DataIt));

23
code/AssetLib/Obj/ObjFileParser.cpp
View File

@ -156,9 +156,17 @@ void ObjFileParser::parseFile(IOStreamBuffer<char> &streamBuffer) {
// read in vertex definition (homogeneous coords) // read in vertex definition (homogeneous coords)
getHomogeneousVector3(m_pModel->mVertices); getHomogeneousVector3(m_pModel->mVertices);
} else if (numComponents == 6) { } else if (numComponents == 6) {
// fill previous omitted vertex-colors by default
if (m_pModel->mVertexColors.size() < m_pModel->mVertices.size()) {
m_pModel->mVertexColors.resize(m_pModel->mVertices.size(), aiVector3D(0, 0, 0));
}
// read vertex and vertex-color // read vertex and vertex-color
getTwoVectors3(m_pModel->mVertices, m_pModel->mVertexColors); getTwoVectors3(m_pModel->mVertices, m_pModel->mVertexColors);
} }
// append omitted vertex-colors as default for the end if any vertex-color exists
if (!m_pModel->mVertexColors.empty() && m_pModel->mVertexColors.size() < m_pModel->mVertices.size()) {
m_pModel->mVertexColors.resize(m_pModel->mVertices.size(), aiVector3D(0, 0, 0));
}
} else if (*m_DataIt == 't') { } else if (*m_DataIt == 't') {
// read in texture coordinate ( 2D or 3D ) // read in texture coordinate ( 2D or 3D )
++m_DataIt; ++m_DataIt;
@ -456,8 +464,19 @@ void ObjFileParser::getFace(aiPrimitiveType type) {
iPos = 0; iPos = 0;
} else { } else {
//OBJ USES 1 Base ARRAYS!!!! //OBJ USES 1 Base ARRAYS!!!!
const char *token = &(*m_DataIt); int iVal;
const int iVal = ::atoi(token); auto end = m_DataIt;
// find either the buffer end or the '\0'
while (end < m_DataItEnd && *end != '\0')
++end;
// avoid temporary string allocation if there is a zero
if (end != m_DataItEnd) {
iVal = ::atoi(&(*m_DataIt));
} else {
// otherwise make a zero terminated copy, which is safe to pass to atoi
std::string number(&(*m_DataIt), m_DataItEnd - m_DataIt);
iVal = ::atoi(number.c_str());
}
// increment iStep position based off of the sign and # of digits // increment iStep position based off of the sign and # of digits
int tmp = iVal; int tmp = iVal;

5
code/AssetLib/SMD/SMDLoader.cpp
View File

@ -837,7 +837,10 @@ void SMDImporter::ParseNodeInfo(const char* szCurrent, const char** szCurrentOut
unsigned int iBone = 0; unsigned int iBone = 0;
SkipSpacesAndLineEnd(szCurrent,&szCurrent); SkipSpacesAndLineEnd(szCurrent,&szCurrent);
if ( !ParseUnsignedInt(szCurrent,&szCurrent,iBone) || !SkipSpaces(szCurrent,&szCurrent)) { if ( !ParseUnsignedInt(szCurrent,&szCurrent,iBone) || !SkipSpaces(szCurrent,&szCurrent)) {
LogErrorNoThrow("Unexpected EOF/EOL while parsing bone index"); throw DeadlyImportError("Unexpected EOF/EOL while parsing bone index");
}
if (iBone == UINT_MAX) {
LogErrorNoThrow("Invalid bone number while parsing bone index");
SMDI_PARSE_RETURN; SMDI_PARSE_RETURN;
} }
// add our bone to the list // add our bone to the list

10
code/AssetLib/glTF/glTFImporter.cpp
View File

@ -93,7 +93,10 @@ const aiImporterDesc *glTFImporter::GetInfo() const {
bool glTFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /* checkSig */) const { bool glTFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /* checkSig */) const {
glTF::Asset asset(pIOHandler); glTF::Asset asset(pIOHandler);
try { try {
asset.Load(pFile, GetExtension(pFile) == "glb"); asset.Load(pFile,
CheckMagicToken(
pIOHandler, pFile, AI_GLB_MAGIC_NUMBER, 1, 0,
static_cast<unsigned int>(strlen(AI_GLB_MAGIC_NUMBER))));
return asset.asset; return asset.asset;
} catch (...) { } catch (...) {
return false; return false;
@ -697,7 +700,10 @@ void glTFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOS
// read the asset file // read the asset file
glTF::Asset asset(pIOHandler); glTF::Asset asset(pIOHandler);
asset.Load(pFile, GetExtension(pFile) == "glb"); asset.Load(pFile,
CheckMagicToken(
pIOHandler, pFile, AI_GLB_MAGIC_NUMBER, 1, 0,
static_cast<unsigned int>(strlen(AI_GLB_MAGIC_NUMBER))));
// //
// Copy the data out // Copy the data out

11
code/AssetLib/glTF2/glTF2Importer.cpp
View File

@ -112,7 +112,11 @@ bool glTF2Importer::CanRead(const std::string &filename, IOSystem *pIOHandler, b
if (pIOHandler) { if (pIOHandler) {
glTF2::Asset asset(pIOHandler); glTF2::Asset asset(pIOHandler);
return asset.CanRead(filename, extension == "glb"); return asset.CanRead(
filename,
CheckMagicToken(
pIOHandler, filename, AI_GLB_MAGIC_NUMBER, 1, 0,
static_cast<unsigned int>(strlen(AI_GLB_MAGIC_NUMBER))));
} }
return false; return false;
@ -1678,7 +1682,10 @@ void glTF2Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IO
// read the asset file // read the asset file
glTF2::Asset asset(pIOHandler, static_cast<rapidjson::IRemoteSchemaDocumentProvider *>(mSchemaDocumentProvider)); glTF2::Asset asset(pIOHandler, static_cast<rapidjson::IRemoteSchemaDocumentProvider *>(mSchemaDocumentProvider));
asset.Load(pFile, GetExtension(pFile) == "glb"); asset.Load(pFile,
CheckMagicToken(
pIOHandler, pFile, AI_GLB_MAGIC_NUMBER, 1, 0,
static_cast<unsigned int>(strlen(AI_GLB_MAGIC_NUMBER))));
if (asset.scene) { if (asset.scene) {
pScene->mName = asset.scene->name; pScene->mName = asset.scene->name;
} }

1
code/CMakeLists.txt
View File

@ -965,7 +965,6 @@ IF(ASSIMP_HUNTER_ENABLED)
find_package(minizip CONFIG REQUIRED) find_package(minizip CONFIG REQUIRED)
ELSE() ELSE()
SET( unzip_SRCS SET( unzip_SRCS
../contrib/unzip/crypt.c
../contrib/unzip/crypt.h ../contrib/unzip/crypt.h
../contrib/unzip/ioapi.c ../contrib/unzip/ioapi.c
../contrib/unzip/ioapi.h ../contrib/unzip/ioapi.h

46
code/Common/BaseImporter.cpp
View File

@ -158,7 +158,7 @@ void BaseImporter::GetExtensionList(std::set<std::string> &extensions) {
std::size_t numTokens, std::size_t numTokens,
unsigned int searchBytes /* = 200 */, unsigned int searchBytes /* = 200 */,
bool tokensSol /* false */, bool tokensSol /* false */,
bool noAlphaBeforeTokens /* false */) { bool noGraphBeforeTokens /* false */) {
ai_assert(nullptr != tokens); ai_assert(nullptr != tokens);
ai_assert(0 != numTokens); ai_assert(0 != numTokens);
ai_assert(0 != searchBytes); ai_assert(0 != searchBytes);
@ -207,8 +207,9 @@ void BaseImporter::GetExtensionList(std::set<std::string> &extensions) {
continue; continue;
} }
// We need to make sure that we didn't accidentally identify the end of another token as our token, // We need to make sure that we didn't accidentally identify the end of another token as our token,
// e.g. in a previous version the "gltf " present in some gltf files was detected as "f " // e.g. in a previous version the "gltf " present in some gltf files was detected as "f ", or a
if (noAlphaBeforeTokens && (r != buffer && isalpha(static_cast<unsigned char>(r[-1])))) { // Blender-exported glb file containing "Khronos glTF Blender I/O " was detected as "o "
if (noGraphBeforeTokens && (r != buffer && isgraph(static_cast<unsigned char>(r[-1])))) {
continue; continue;
} }
// We got a match, either we don't care where it is, or it happens to // We got a match, either we don't care where it is, or it happens to
@ -229,27 +230,30 @@ void BaseImporter::GetExtensionList(std::set<std::string> &extensions) {
const char *ext0, const char *ext0,
const char *ext1, const char *ext1,
const char *ext2) { const char *ext2) {
std::string::size_type pos = pFile.find_last_of('.'); std::set<std::string> extensions;
for (const char* ext : {ext0, ext1, ext2}) {
// no file extension - can't read if (ext == nullptr) continue;
if (pos == std::string::npos) { extensions.emplace(ext);
return false;
} }
return HasExtension(pFile, extensions);
}
const char *ext_real = &pFile[pos + 1]; // ------------------------------------------------------------------------------------------------
if (!ASSIMP_stricmp(ext_real, ext0)) { // Check for file extension
return true; /*static*/ bool BaseImporter::HasExtension(const std::string &pFile, const std::set<std::string> &extensions) {
// CAUTION: Do not just search for the extension!
// GetExtension() returns the part after the *last* dot, but some extensions
// have dots inside them, e.g. ogre.mesh.xml. Compare the entire end of the
// string.
for (const std::string& ext : extensions) {
// Yay for C++<20 not having std::string::ends_with()
const std::string dotExt = "." + ext;
if (dotExt.length() > pFile.length()) continue;
// Possible optimization: Fetch the lowercase filename!
if (0 == ASSIMP_stricmp(pFile.c_str() + pFile.length() - dotExt.length(), dotExt.c_str())) {
return true;
}
} }
// check for other, optional, file extensions
if (ext1 && !ASSIMP_stricmp(ext_real, ext1)) {
return true;
}
if (ext2 && !ASSIMP_stricmp(ext_real, ext2)) {
return true;
}
return false; return false;
} }

2
code/Common/FileSystemFilter.h
View File

@ -297,7 +297,7 @@ private:
} }
const char separator = getOsSeparator(); const char separator = getOsSeparator();
for (it = in.begin(); it != in.end(); ++it) { for (it = in.begin(); it < in.end(); ++it) {
const size_t remaining = std::distance(in.end(), it); const size_t remaining = std::distance(in.end(), it);
// Exclude :// and \\, which remain untouched. // Exclude :// and \\, which remain untouched.
// https://sourceforge.net/tracker/?func=detail&aid=3031725&group_id=226462&atid=1067632 // https://sourceforge.net/tracker/?func=detail&aid=3031725&group_id=226462&atid=1067632

20
code/Common/Importer.cpp
View File

@ -637,24 +637,10 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) {
std::set<std::string> extensions; std::set<std::string> extensions;
pimpl->mImporter[a]->GetExtensionList(extensions); pimpl->mImporter[a]->GetExtensionList(extensions);
// CAUTION: Do not just search for the extension! if (BaseImporter::HasExtension(pFile, extensions)) {
// GetExtension() returns the part after the *last* dot, but some extensions have dots ImporterAndIndex candidate = { pimpl->mImporter[a], a };
// inside them, e.g. ogre.mesh.xml. Compare the entire end of the string. possibleImporters.push_back(candidate);
for (std::set<std::string>::const_iterator it = extensions.cbegin(); it != extensions.cend(); ++it) {
// Yay for C++<20 not having std::string::ends_with()
std::string extension = "." + *it;
if (extension.length() <= pFile.length()) {
// Possible optimization: Fetch the lowercase filename!
if (0 == ASSIMP_stricmp(pFile.c_str() + pFile.length() - extension.length(), extension.c_str())) {
ImporterAndIndex candidate = { pimpl->mImporter[a], a };
possibleImporters.push_back(candidate);
break;
}
}
} }
} }
// If just one importer supports this extension, pick it and close the case. // If just one importer supports this extension, pick it and close the case.

8
code/Material/MaterialSystem.cpp
View File

@ -51,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/material.h> #include <assimp/material.h>
#include <assimp/types.h> #include <assimp/types.h>
#include <assimp/DefaultLogger.hpp> #include <assimp/DefaultLogger.hpp>
#include <memory>
using namespace Assimp; using namespace Assimp;
@ -473,7 +474,7 @@ aiReturn aiMaterial::AddBinaryProperty(const void *pInput,
} }
// Allocate a new material property // Allocate a new material property
aiMaterialProperty *pcNew = new aiMaterialProperty(); std::unique_ptr<aiMaterialProperty> pcNew(new aiMaterialProperty());
// .. and fill it // .. and fill it
pcNew->mType = pType; pcNew->mType = pType;
@ -489,7 +490,7 @@ aiReturn aiMaterial::AddBinaryProperty(const void *pInput,
strcpy(pcNew->mKey.data, pKey); strcpy(pcNew->mKey.data, pKey);
if (UINT_MAX != iOutIndex) { if (UINT_MAX != iOutIndex) {
mProperties[iOutIndex] = pcNew; mProperties[iOutIndex] = pcNew.release();
return AI_SUCCESS; return AI_SUCCESS;
} }
@ -502,7 +503,6 @@ aiReturn aiMaterial::AddBinaryProperty(const void *pInput,
try { try {
ppTemp = new aiMaterialProperty *[mNumAllocated]; ppTemp = new aiMaterialProperty *[mNumAllocated];
} catch (std::bad_alloc &) { } catch (std::bad_alloc &) {
delete pcNew;
return AI_OUTOFMEMORY; return AI_OUTOFMEMORY;
} }
@ -513,7 +513,7 @@ aiReturn aiMaterial::AddBinaryProperty(const void *pInput,
mProperties = ppTemp; mProperties = ppTemp;
} }
// push back ... // push back ...
mProperties[mNumProperties++] = pcNew; mProperties[mNumProperties++] = pcNew.release();
return AI_SUCCESS; return AI_SUCCESS;
} }

11
code/PostProcessing/FindInvalidDataProcess.cpp
View File

@ -82,6 +82,9 @@ void UpdateMeshReferences(aiNode *node, const std::vector<unsigned int> &meshMap
for (unsigned int a = 0; a < node->mNumMeshes; ++a) { for (unsigned int a = 0; a < node->mNumMeshes; ++a) {
unsigned int ref = node->mMeshes[a]; unsigned int ref = node->mMeshes[a];
if (ref >= meshMapping.size())
throw DeadlyImportError("Invalid mesh ref");
if (UINT_MAX != (ref = meshMapping[ref])) { if (UINT_MAX != (ref = meshMapping[ref])) {
node->mMeshes[out++] = ref; node->mMeshes[out++] = ref;
} }
@ -143,7 +146,13 @@ void FindInvalidDataProcess::Execute(aiScene *pScene) {
// we need to remove some meshes. // we need to remove some meshes.
// therefore we'll also need to remove all references // therefore we'll also need to remove all references
// to them from the scenegraph // to them from the scenegraph
UpdateMeshReferences(pScene->mRootNode, meshMapping); try {
UpdateMeshReferences(pScene->mRootNode, meshMapping);
} catch (const std::exception&) {
// fix the real number of meshes otherwise we'll get double free in the scene destructor
pScene->mNumMeshes = real;
throw;
}
pScene->mNumMeshes = real; pScene->mNumMeshes = real;
} }

2
contrib/pugixml/readme.txt
View File

@ -1,4 +1,4 @@
pugixml 1.12 - an XML processing library pugixml 1.13 - an XML processing library
Copyright (C) 2006-2022, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com) Copyright (C) 2006-2022, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
Report bugs and download new versions at https://pugixml.org/ Report bugs and download new versions at https://pugixml.org/

172
contrib/unzip/crypt.c
View File

@ -1,172 +0,0 @@
/* crypt.c -- base code for traditional PKWARE encryption
Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant
Modifications for Info-ZIP crypting
Copyright (C) 2003 Terry Thorsen
This code is a modified version of crypting code in Info-ZIP distribution
Copyright (C) 1990-2000 Info-ZIP. All rights reserved.
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
This encryption code is a direct transcription of the algorithm from
Roger Schlafly, described by Phil Katz in the file appnote.txt. This
file (appnote.txt) is distributed with the PKZIP program (even in the
version without encryption capabilities).
If you don't need crypting in your application, just define symbols
NOCRYPT and NOUNCRYPT.
*/
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
#define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS 0
#endif
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <time.h>
#ifdef _WIN32
# include <windows.h>
# include <wincrypt.h>
#else
# include <sys/stat.h>
# include <fcntl.h>
# include <unistd.h>
#endif
#include "zlib.h"
#include "crypt.h"
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable : 4244)
#endif // _MSC_VER
/***************************************************************************/
#define CRC32(c, b) ((*(pcrc_32_tab+(((uint32_t)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
#ifndef ZCR_SEED2
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
#endif
/***************************************************************************/
uint8_t decrypt_byte(uint32_t *pkeys)
{
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
* unpredictable manner on 16-bit systems; not a problem
* with any known compiler so far, though */
temp = ((uint32_t)(*(pkeys+2)) & 0xffff) | 2;
return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
}
uint8_t update_keys(uint32_t *pkeys, const z_crc_t *pcrc_32_tab, int32_t c)
{
(*(pkeys+0)) = (uint32_t)CRC32((*(pkeys+0)), c);
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
{
register int32_t keyshift = (int32_t)((*(pkeys + 1)) >> 24);
(*(pkeys+2)) = (uint32_t)CRC32((*(pkeys+2)), keyshift);
}
return c;
}
void init_keys(const char *passwd, uint32_t *pkeys, const z_crc_t *pcrc_32_tab)
{
*(pkeys+0) = 305419896L;
*(pkeys+1) = 591751049L;
*(pkeys+2) = 878082192L;
while (*passwd != 0)
{
update_keys(pkeys, pcrc_32_tab, *passwd);
passwd += 1;
}
}
/***************************************************************************/
int cryptrand(unsigned char *buf, unsigned int len)
{
static unsigned calls = 0;
int rlen = 0;
#ifdef _WIN32
HCRYPTPROV provider;
unsigned __int64 pentium_tsc[1];
int result = 0;
#if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP
if (CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
{
result = CryptGenRandom(provider, len, buf);
CryptReleaseContext(provider, 0);
if (result)
return len;
}
#endif
for (rlen = 0; rlen < (int)len; ++rlen)
{
if (rlen % 8 == 0)
QueryPerformanceCounter((LARGE_INTEGER *)pentium_tsc);
buf[rlen] = ((unsigned char*)pentium_tsc)[rlen % 8];
}
#else
int frand = open("/dev/urandom", O_RDONLY);
if (frand != -1)
{
rlen = (int)read(frand, buf, len);
close(frand);
}
#endif
if (rlen < (int)len)
{
/* Ensure different random header each time */
if (++calls == 1)
srand((unsigned)(time(NULL) ^ ZCR_SEED2));
while (rlen < (int)len)
buf[rlen++] = (rand() >> 7) & 0xff;
}
return rlen;
}
int crypthead(const char *passwd, uint8_t *buf, int buf_size, uint32_t *pkeys,
const z_crc_t *pcrc_32_tab, uint8_t verify1, uint8_t verify2)
{
uint8_t n = 0; /* index in random header */
uint8_t header[RAND_HEAD_LEN-2]; /* random header */
uint16_t t = 0; /* temporary */
if (buf_size < RAND_HEAD_LEN)
return 0;
init_keys(passwd, pkeys, pcrc_32_tab);
/* First generate RAND_HEAD_LEN-2 random bytes. */
cryptrand(header, RAND_HEAD_LEN-2);
/* Encrypt random header (last two bytes is high word of crc) */
init_keys(passwd, pkeys, pcrc_32_tab);
for (n = 0; n < RAND_HEAD_LEN-2; n++)
buf[n] = (uint8_t)zencode(pkeys, pcrc_32_tab, header[n], t);
buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify1, t);
buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify2, t);
return n;
}
#ifdef _MSC_VER
# pragma warning(pop)
#endif // _MSC_VER
/***************************************************************************/

147
contrib/unzip/crypt.h
View File

@ -1,63 +1,132 @@
/* crypt.h -- base code for traditional PKWARE encryption /* crypt.h -- base code for crypt/uncrypt ZIPfile
Version 1.01e, February 12th, 2005 Version 1.01e, February 12th, 2005
Copyright (C) 1998-2005 Gilles Vollant Copyright (C) 1998-2005 Gilles Vollant
Modifications for Info-ZIP crypting
Copyright (C) 2003 Terry Thorsen
This code is a modified version of crypting code in Info-ZIP distribution This code is a modified version of crypting code in Infozip distribution
Copyright (C) 1990-2000 Info-ZIP. All rights reserved. The encryption/decryption parts of this source code (as opposed to the
non-echoing password parts) were originally written in Europe. The
whole source package can be freely distributed, including from the USA.
(Prior to January 2000, re-export from the US was a violation of US law.)
This program is distributed under the terms of the same license as zlib. This encryption code is a direct transcription of the algorithm from
See the accompanying LICENSE file for the full text of the license. Roger Schlafly, described by Phil Katz in the file appnote.txt. This
file (appnote.txt) is distributed with the PKZIP program (even in the
version without encryption capabilities).
If you don't need crypting in your application, just define symbols
NOCRYPT and NOUNCRYPT.
This code support the "Traditional PKWARE Encryption".
The new AES encryption added on Zip format by Winzip (see the page
http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
Encryption is not supported.
*/ */
#ifndef _MINICRYPT_H #define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
#define _MINICRYPT_H
#if ZLIB_VERNUM < 0x1270 /***********************************************************************
#if !defined(Z_U4) * Return the next byte in the pseudo-random sequence
typedef unsigned long z_crc_t; */
#endif static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)
#endif {
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
* unpredictable manner on 16-bit systems; not a problem
* with any known compiler so far, though */
#ifdef __cplusplus (void)pcrc_32_tab;
extern "C" { temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
#endif return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
}
#define RAND_HEAD_LEN 12 /***********************************************************************
* Update the encryption keys with the next byte of plain text
*/
static int update_keys(unsigned long* pkeys,const z_crc_t* pcrc_32_tab,int c)
{
(*(pkeys+0)) = CRC32((*(pkeys+0)), c);
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
{
register int keyshift = (int)((*(pkeys+1)) >> 24);
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
}
return c;
}
/***************************************************************************/
/***********************************************************************
* Initialize the encryption keys and the random header according to
* the given password.
*/
static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcrc_32_tab)
{
*(pkeys+0) = 305419896L;
*(pkeys+1) = 591751049L;
*(pkeys+2) = 878082192L;
while (*passwd != '\0') {
update_keys(pkeys,pcrc_32_tab,(int)*passwd);
passwd++;
}
}
#define zdecode(pkeys,pcrc_32_tab,c) \ #define zdecode(pkeys,pcrc_32_tab,c) \
(update_keys(pkeys,pcrc_32_tab, c ^= decrypt_byte(pkeys))) (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
#define zencode(pkeys,pcrc_32_tab,c,t) \ #define zencode(pkeys,pcrc_32_tab,c,t) \
(t = decrypt_byte(pkeys), update_keys(pkeys,pcrc_32_tab,c), t^(c)) (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), (Byte)t^(c))
/***************************************************************************/ #ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
/* Return the next byte in the pseudo-random sequence */ #define RAND_HEAD_LEN 12
uint8_t decrypt_byte(uint32_t *pkeys); /* "last resort" source for second part of crypt seed pattern */
# ifndef ZCR_SEED2
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
# endif
/* Update the encryption keys with the next byte of plain text */ static unsigned crypthead(const char* passwd, /* password string */
uint8_t update_keys(uint32_t *pkeys, const z_crc_t *pcrc_32_tab, int32_t c); unsigned char* buf, /* where to write header */
int bufSize,
unsigned long* pkeys,
const z_crc_t* pcrc_32_tab,
unsigned long crcForCrypting)
{
unsigned n; /* index in random header */
int t; /* temporary */
int c; /* random byte */
unsigned char header[RAND_HEAD_LEN-2]; /* random header */
static unsigned calls = 0; /* ensure different random header each time */
/* Initialize the encryption keys and the random header according to the given password. */ if (bufSize<RAND_HEAD_LEN)
void init_keys(const char *passwd, uint32_t *pkeys, const z_crc_t *pcrc_32_tab); return 0;
/* Generate cryptographically secure random numbers */ /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
int cryptrand(unsigned char *buf, unsigned int len); * output of rand() to get less predictability, since rand() is
* often poorly implemented.
/* Create encryption header */ */
int crypthead(const char *passwd, uint8_t *buf, int buf_size, uint32_t *pkeys, if (++calls == 1)
const z_crc_t *pcrc_32_tab, uint8_t verify1, uint8_t verify2); {
srand((unsigned)(time(NULL) ^ ZCR_SEED2));
/***************************************************************************/ }
init_keys(passwd, pkeys, pcrc_32_tab);
#ifdef __cplusplus for (n = 0; n < RAND_HEAD_LEN-2; n++)
{
c = (rand() >> 7) & 0xff;
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
}
/* Encrypt random header (last two bytes is high word of crc) */
init_keys(passwd, pkeys, pcrc_32_tab);
for (n = 0; n < RAND_HEAD_LEN-2; n++)
{
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
}
buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
return n;
} }
#endif
#endif #endif

383
contrib/unzip/ioapi.c
View File

@ -1,81 +1,75 @@
/* ioapi.c -- IO base function header for compress/uncompress .zip /* ioapi.h -- IO base function header for compress/uncompress .zip
part of the MiniZip project part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
Copyright (C) 1998-2010 Gilles Vollant Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
http://www.winimage.com/zLibDll/minizip.html
Modifications for Zip64 support Modifications for Zip64 support
Copyright (C) 2009-2010 Mathias Svensson Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
http://result42.com
For more info read MiniZip_info.txt
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
*/ */
#include <stdlib.h> #if defined(_WIN32) && (!(defined(_CRT_SECURE_NO_WARNINGS)))
#include <string.h> #define _CRT_SECURE_NO_WARNINGS
#if defined unix || defined __APPLE__
#include <sys/types.h>
#include <unistd.h>
#endif #endif
#if defined(__APPLE__) || defined(IOAPI_NO_64)
// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
#define FTELLO_FUNC(stream) ftello(stream)
#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
#else
#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
#define FTELLO_FUNC(stream) ftello64(stream)
#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
#endif
#include "ioapi.h" #include "ioapi.h"
#ifdef _WIN32 voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
# define snprintf _snprintf
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable : 4131 4100)
#endif
# ifdef __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunused-parameter"
# endif
#endif // _WIN32
voidpf call_zopen64(const zlib_filefunc64_32_def *pfilefunc, const void *filename, int mode)
{ {
if (pfilefunc->zfile_func64.zopen64_file != NULL) if (pfilefunc->zfile_func64.zopen64_file != NULL)
return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque, filename, mode); return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque, (const char*)filename, mode); else
{
return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
}
} }
voidpf call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode) long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
{ {
if (pfilefunc->zfile_func64.zopendisk64_file != NULL)
return (*(pfilefunc->zfile_func64.zopendisk64_file)) (pfilefunc->zfile_func64.opaque, filestream, number_disk, mode);
return (*(pfilefunc->zopendisk32_file))(pfilefunc->zfile_func64.opaque, filestream, number_disk, mode);
}
long call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin)
{
uint32_t offset_truncated = 0;
if (pfilefunc->zfile_func64.zseek64_file != NULL) if (pfilefunc->zfile_func64.zseek64_file != NULL)
return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin); return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
offset_truncated = (uint32_t)offset; else
if (offset_truncated != offset) {
return -1; uLong offsetTruncated = (uLong)offset;
return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream, offset_truncated, origin); if (offsetTruncated != offset)
return -1;
else
return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
}
} }
uint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream) ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
{ {
uint64_t position;
if (pfilefunc->zfile_func64.zseek64_file != NULL) if (pfilefunc->zfile_func64.zseek64_file != NULL)
return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque, filestream); return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
position = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque, filestream); else
if ((position) == UINT32_MAX) {
return (uint64_t)-1; uLong tell_uLong = (uLong)(*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
return position; if ((tell_uLong) == MAXU32)
return (ZPOS64_T)-1;
else
return tell_uLong;
}
} }
void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32) void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
{ {
p_filefunc64_32->zfile_func64.zopen64_file = NULL; p_filefunc64_32->zfile_func64.zopen64_file = NULL;
p_filefunc64_32->zfile_func64.zopendisk64_file = NULL;
p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file; p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
p_filefunc64_32->zopendisk32_file = p_filefunc32->zopendisk_file;
p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file; p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file; p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
@ -88,255 +82,158 @@ void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filef
p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file; p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
} }
static voidpf ZCALLBACK fopen_file_func(voidpf opaque, const char *filename, int mode);
static uint32_t ZCALLBACK fread_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size);
static uint32_t ZCALLBACK fwrite_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size);
static uint64_t ZCALLBACK ftell64_file_func(voidpf opaque, voidpf stream);
static long ZCALLBACK fseek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin);
static int ZCALLBACK fclose_file_func(voidpf opaque, voidpf stream);
static int ZCALLBACK ferror_file_func(voidpf opaque, voidpf stream);
typedef struct
{
FILE *file;
int filenameLength;
void *filename;
} FILE_IOPOSIX;
static voidpf file_build_ioposix(FILE *file, const char *filename) static voidpf ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
{ static uLong ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
FILE_IOPOSIX *ioposix = NULL; static uLong ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
if (file == NULL) static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
return NULL; static long ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
ioposix = (FILE_IOPOSIX*)malloc(sizeof(FILE_IOPOSIX)); static int ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
ioposix->file = file; static int ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
ioposix->filenameLength = (int)strlen(filename) + 1;
ioposix->filename = (char*)malloc(ioposix->filenameLength * sizeof(char));
memcpy((char*)ioposix->filename, filename, ioposix->filenameLength);
return (voidpf)ioposix;
}
static voidpf ZCALLBACK fopen_file_func(voidpf opaque, const char *filename, int mode) static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
{ {
FILE* file = NULL; FILE* file = NULL;
const char *mode_fopen = NULL; const char* mode_fopen = NULL;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) (void)opaque;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
mode_fopen = "rb"; mode_fopen = "rb";
else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) else
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
mode_fopen = "r+b"; mode_fopen = "r+b";
else if (mode & ZLIB_FILEFUNC_MODE_CREATE) else
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
mode_fopen = "wb"; mode_fopen = "wb";
if ((filename != NULL) && (mode_fopen != NULL)) if ((filename!=NULL) && (mode_fopen != NULL))
{
file = fopen(filename, mode_fopen); file = fopen(filename, mode_fopen);
return file_build_ioposix(file, filename);
}
return file; return file;
} }
static voidpf ZCALLBACK fopen64_file_func(voidpf opaque, const void *filename, int mode) static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
{ {
FILE* file = NULL; FILE* file = NULL;
const char *mode_fopen = NULL; const char* mode_fopen = NULL;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) (void)opaque;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
mode_fopen = "rb"; mode_fopen = "rb";
else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) else
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
mode_fopen = "r+b"; mode_fopen = "r+b";
else if (mode & ZLIB_FILEFUNC_MODE_CREATE) else
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
mode_fopen = "wb"; mode_fopen = "wb";
if ((filename != NULL) && (mode_fopen != NULL)) if ((filename!=NULL) && (mode_fopen != NULL))
{ file = FOPEN_FUNC((const char*)filename, mode_fopen);
file = fopen64((const char*)filename, mode_fopen);
return file_build_ioposix(file, (const char*)filename);
}
return file; return file;
} }
static voidpf ZCALLBACK fopendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode)
{
FILE_IOPOSIX *ioposix = NULL;
char *diskFilename = NULL;
voidpf ret = NULL;
int i = 0;
if (stream == NULL) static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
return NULL; {
ioposix = (FILE_IOPOSIX*)stream; uLong ret;
diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char)); (void)opaque;
strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength); ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)
{
if (diskFilename[i] != '.')
continue;
snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02u", number_disk + 1);
break;
}
if (i >= 0)
ret = fopen64_file_func(opaque, diskFilename, mode);
free(diskFilename);
return ret; return ret;
} }
static voidpf ZCALLBACK fopendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
{ {
FILE_IOPOSIX *ioposix = NULL; uLong ret;
char *diskFilename = NULL; (void)opaque;
voidpf ret = NULL; ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
int i = 0;
if (stream == NULL)
return NULL;
ioposix = (FILE_IOPOSIX*)stream;
diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char));
strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength);
for (i = ioposix->filenameLength - 1; i >= 0; i -= 1)
{
if (diskFilename[i] != '.')
continue;
snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02u", number_disk + 1);
break;
}
if (i >= 0)
ret = fopen_file_func(opaque, diskFilename, mode);
free(diskFilename);
return ret; return ret;
} }
static uint32_t ZCALLBACK fread_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size) static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
{ {
FILE_IOPOSIX *ioposix = NULL; long ret;
uint32_t read = (uint32_t)-1; (void)opaque;
if (stream == NULL) ret = ftell((FILE *)stream);
return read;
ioposix = (FILE_IOPOSIX*)stream;
read = (uint32_t)fread(buf, 1, (size_t)size, ioposix->file);
return read;
}
static uint32_t ZCALLBACK fwrite_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size)
{
FILE_IOPOSIX *ioposix = NULL;
uint32_t written = (uint32_t)-1;
if (stream == NULL)
return written;
ioposix = (FILE_IOPOSIX*)stream;
written = (uint32_t)fwrite(buf, 1, (size_t)size, ioposix->file);
return written;
}
static long ZCALLBACK ftell_file_func(voidpf opaque, voidpf stream)
{
FILE_IOPOSIX *ioposix = NULL;
long ret = -1;
if (stream == NULL)
return ret;
ioposix = (FILE_IOPOSIX*)stream;
ret = ftell(ioposix->file);
return ret; return ret;
} }
static uint64_t ZCALLBACK ftell64_file_func(voidpf opaque, voidpf stream)
static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
{ {
FILE_IOPOSIX *ioposix = NULL; ZPOS64_T ret;
uint64_t ret = (uint64_t)-1; (void)opaque;
if (stream == NULL) ret = (ZPOS64_T)FTELLO_FUNC((FILE *)stream);
return ret;
ioposix = (FILE_IOPOSIX*)stream;
ret = ftello64(ioposix->file);
return ret; return ret;
} }
static long ZCALLBACK fseek_file_func(voidpf opaque, voidpf stream, uint32_t offset, int origin) static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offset, int origin)
{ {
FILE_IOPOSIX *ioposix = NULL; int fseek_origin=0;
int fseek_origin = 0; long ret;
long ret = 0; (void)opaque;
if (stream == NULL)
return -1;
ioposix = (FILE_IOPOSIX*)stream;
switch (origin) switch (origin)
{ {
case ZLIB_FILEFUNC_SEEK_CUR: case ZLIB_FILEFUNC_SEEK_CUR :
fseek_origin = SEEK_CUR; fseek_origin = SEEK_CUR;
break; break;
case ZLIB_FILEFUNC_SEEK_END: case ZLIB_FILEFUNC_SEEK_END :
fseek_origin = SEEK_END; fseek_origin = SEEK_END;
break; break;
case ZLIB_FILEFUNC_SEEK_SET: case ZLIB_FILEFUNC_SEEK_SET :
fseek_origin = SEEK_SET; fseek_origin = SEEK_SET;
break; break;
default: default: return -1;
return -1;
} }
if (fseek(ioposix->file, offset, fseek_origin) != 0) ret = 0;
if (fseek((FILE *)stream, (long)offset, fseek_origin) != 0)
ret = -1; ret = -1;
return ret; return ret;
} }
static long ZCALLBACK fseek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin) static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)
{ {
FILE_IOPOSIX *ioposix = NULL; int fseek_origin=0;
int fseek_origin = 0; long ret;
long ret = 0; (void)opaque;
if (stream == NULL)
return -1;
ioposix = (FILE_IOPOSIX*)stream;
switch (origin) switch (origin)
{ {
case ZLIB_FILEFUNC_SEEK_CUR: case ZLIB_FILEFUNC_SEEK_CUR :
fseek_origin = SEEK_CUR; fseek_origin = SEEK_CUR;
break; break;
case ZLIB_FILEFUNC_SEEK_END: case ZLIB_FILEFUNC_SEEK_END :
fseek_origin = SEEK_END; fseek_origin = SEEK_END;
break; break;
case ZLIB_FILEFUNC_SEEK_SET: case ZLIB_FILEFUNC_SEEK_SET :
fseek_origin = SEEK_SET; fseek_origin = SEEK_SET;
break; break;
default: default: return -1;
return -1;
} }
ret = 0;
if (fseeko64(ioposix->file, offset, fseek_origin) != 0) if(FSEEKO_FUNC((FILE *)stream, (z_off_t)offset, fseek_origin) != 0)
ret = -1; ret = -1;
return ret; return ret;
} }
static int ZCALLBACK fclose_file_func(voidpf opaque, voidpf stream)
static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
{ {
FILE_IOPOSIX *ioposix = NULL; int ret;
int ret = -1; (void)opaque;
if (stream == NULL) ret = fclose((FILE *)stream);
return ret;
ioposix = (FILE_IOPOSIX*)stream;
if (ioposix->filename != NULL)
free(ioposix->filename);
ret = fclose(ioposix->file);
free(ioposix);
return ret; return ret;
} }
static int ZCALLBACK ferror_file_func(voidpf opaque, voidpf stream) static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
{ {
FILE_IOPOSIX *ioposix = NULL; int ret;
int ret = -1; (void)opaque;
if (stream == NULL) ret = ferror((FILE *)stream);
return ret;
ioposix = (FILE_IOPOSIX*)stream;
ret = ferror(ioposix->file);
return ret; return ret;
} }
void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def) void fill_fopen_filefunc (zlib_filefunc_def* pzlib_filefunc_def)
{ {
pzlib_filefunc_def->zopen_file = fopen_file_func; pzlib_filefunc_def->zopen_file = fopen_file_func;
pzlib_filefunc_def->zopendisk_file = fopendisk_file_func;
pzlib_filefunc_def->zread_file = fread_file_func; pzlib_filefunc_def->zread_file = fread_file_func;
pzlib_filefunc_def->zwrite_file = fwrite_file_func; pzlib_filefunc_def->zwrite_file = fwrite_file_func;
pzlib_filefunc_def->ztell_file = ftell_file_func; pzlib_filefunc_def->ztell_file = ftell_file_func;
@ -346,10 +243,9 @@ void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def)
pzlib_filefunc_def->opaque = NULL; pzlib_filefunc_def->opaque = NULL;
} }
void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def) void fill_fopen64_filefunc (zlib_filefunc64_def* pzlib_filefunc_def)
{ {
pzlib_filefunc_def->zopen64_file = fopen64_file_func; pzlib_filefunc_def->zopen64_file = fopen64_file_func;
pzlib_filefunc_def->zopendisk64_file = fopendisk64_file_func;
pzlib_filefunc_def->zread_file = fread_file_func; pzlib_filefunc_def->zread_file = fread_file_func;
pzlib_filefunc_def->zwrite_file = fwrite_file_func; pzlib_filefunc_def->zwrite_file = fwrite_file_func;
pzlib_filefunc_def->ztell64_file = ftell64_file_func; pzlib_filefunc_def->ztell64_file = ftell64_file_func;
@ -358,10 +254,3 @@ void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def)
pzlib_filefunc_def->zerror_file = ferror_file_func; pzlib_filefunc_def->zerror_file = ferror_file_func;
pzlib_filefunc_def->opaque = NULL; pzlib_filefunc_def->opaque = NULL;
} }
#ifdef _MSC_VER
# pragma warning(pop)
# ifdef __clang__
# pragma clang diagnostic pop
# endif
#endif // _MSC_VER

221
contrib/unzip/ioapi.h
View File

@ -1,142 +1,207 @@
/* ioapi.h -- IO base function header for compress/uncompress .zip /* ioapi.h -- IO base function header for compress/uncompress .zip
part of the MiniZip project part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
Copyright (C) 1998-2010 Gilles Vollant Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
http://www.winimage.com/zLibDll/minizip.html
Modifications for Zip64 support Modifications for Zip64 support
Copyright (C) 2009-2010 Mathias Svensson Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
http://result42.com
For more info read MiniZip_info.txt
Changes
Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
More if/def section may be needed to support other platforms
Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
(but you should use iowin32.c for windows instead)
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
*/ */
#ifndef _ZLIBIOAPI64_H #ifndef _ZLIBIOAPI64_H
#define _ZLIBIOAPI64_H #define _ZLIBIOAPI64_H
#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
// Linux needs this to support file operation on files larger then 4+GB
// But might need better if/def to select just the platforms that needs them.
#ifndef __USE_FILE_OFFSET64
#define __USE_FILE_OFFSET64
#endif
#ifndef __USE_LARGEFILE64
#define __USE_LARGEFILE64
#endif
#ifndef _LARGEFILE64_SOURCE
#define _LARGEFILE64_SOURCE
#endif
#ifndef _FILE_OFFSET_BIT
#define _FILE_OFFSET_BIT 64
#endif
#endif
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdint.h>
#include "zlib.h" #include "zlib.h"
#if defined(USE_FILE32API) #if defined(USE_FILE32API)
# define fopen64 fopen #define fopen64 fopen
# define ftello64 ftell #define ftello64 ftell
# define fseeko64 fseek #define fseeko64 fseek
#else #else
#if defined(_MSC_VER) #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
# define fopen64 fopen #define fopen64 fopen
# if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC))) #define ftello64 ftello
# define ftello64 _ftelli64 #define fseeko64 fseeko
# define fseeko64 _fseeki64
# else /* old MSC */
# define ftello64 ftell
# define fseeko64 fseek
# endif
#else
# define fopen64 fopen
# define ftello64 ftello
# define fseeko64 fseeko
#endif #endif
#ifdef _MSC_VER
#define fopen64 fopen
#if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
#define ftello64 _ftelli64
#define fseeko64 _fseeki64
#else // old MSC
#define ftello64 ftell
#define fseeko64 fseek
#endif
#endif
#endif
/*
#ifndef ZPOS64_T
#ifdef _WIN32
#define ZPOS64_T fpos_t
#else
#include <stdint.h>
#define ZPOS64_T uint64_t
#endif
#endif
*/
#ifdef HAVE_MINIZIP64_CONF_H
#include "mz64conf.h"
#endif
/* a type choosen by DEFINE */
#ifdef HAVE_64BIT_INT_CUSTOM
typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;
#else
#ifdef HAS_STDINT_H
#include "stdint.h"
typedef uint64_t ZPOS64_T;
#else
#if defined(_MSC_VER) || defined(__BORLANDC__)
typedef unsigned __int64 ZPOS64_T;
#else
typedef unsigned long long int ZPOS64_T;
#endif
#endif
#endif
/* Maximum unsigned 32-bit value used as placeholder for zip64 */
#ifndef MAXU32
#define MAXU32 (0xffffffff)
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define ZLIB_FILEFUNC_SEEK_CUR (1) #define ZLIB_FILEFUNC_SEEK_CUR (1)
#define ZLIB_FILEFUNC_SEEK_END (2) #define ZLIB_FILEFUNC_SEEK_END (2)
#define ZLIB_FILEFUNC_SEEK_SET (0) #define ZLIB_FILEFUNC_SEEK_SET (0)
#define ZLIB_FILEFUNC_MODE_READ (1) #define ZLIB_FILEFUNC_MODE_READ (1)
#define ZLIB_FILEFUNC_MODE_WRITE (2) #define ZLIB_FILEFUNC_MODE_WRITE (2)
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) #define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
#define ZLIB_FILEFUNC_MODE_EXISTING (4)
#define ZLIB_FILEFUNC_MODE_CREATE (8) #define ZLIB_FILEFUNC_MODE_EXISTING (4)
#define ZLIB_FILEFUNC_MODE_CREATE (8)
#ifndef ZCALLBACK #ifndef ZCALLBACK
# if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \ #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) #define ZCALLBACK CALLBACK
# define ZCALLBACK CALLBACK #else
# else #define ZCALLBACK
# define ZCALLBACK #endif
# endif
#endif #endif
typedef voidpf (ZCALLBACK *open_file_func) (voidpf opaque, const char *filename, int mode);
typedef voidpf (ZCALLBACK *opendisk_file_func) (voidpf opaque, voidpf stream, uint32_t number_disk, int mode);
typedef uint32_t (ZCALLBACK *read_file_func) (voidpf opaque, voidpf stream, void* buf, uint32_t size);
typedef uint32_t (ZCALLBACK *write_file_func) (voidpf opaque, voidpf stream, const void *buf, uint32_t size);
typedef int (ZCALLBACK *close_file_func) (voidpf opaque, voidpf stream);
typedef int (ZCALLBACK *error_file_func) (voidpf opaque, voidpf stream);
typedef long (ZCALLBACK *tell_file_func) (voidpf opaque, voidpf stream);
typedef long (ZCALLBACK *seek_file_func) (voidpf opaque, voidpf stream, uint32_t offset, int origin);
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
/* here is the "old" 32 bits structure structure */ /* here is the "old" 32 bits structure structure */
typedef struct zlib_filefunc_def_s typedef struct zlib_filefunc_def_s
{ {
open_file_func zopen_file; open_file_func zopen_file;
opendisk_file_func zopendisk_file;
read_file_func zread_file; read_file_func zread_file;
write_file_func zwrite_file; write_file_func zwrite_file;
tell_file_func ztell_file; tell_file_func ztell_file;
seek_file_func zseek_file; seek_file_func zseek_file;
close_file_func zclose_file; close_file_func zclose_file;
error_file_func zerror_file; testerror_file_func zerror_file;
voidpf opaque; voidpf opaque;
} zlib_filefunc_def; } zlib_filefunc_def;
typedef uint64_t (ZCALLBACK *tell64_file_func) (voidpf opaque, voidpf stream); typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream));
typedef long (ZCALLBACK *seek64_file_func) (voidpf opaque, voidpf stream, uint64_t offset, int origin); typedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
typedef voidpf (ZCALLBACK *open64_file_func) (voidpf opaque, const void *filename, int mode); typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode));
typedef voidpf (ZCALLBACK *opendisk64_file_func)(voidpf opaque, voidpf stream, uint32_t number_disk, int mode);
typedef struct zlib_filefunc64_def_s typedef struct zlib_filefunc64_def_s
{ {
open64_file_func zopen64_file; open64_file_func zopen64_file;
opendisk64_file_func zopendisk64_file; read_file_func zread_file;
read_file_func zread_file; write_file_func zwrite_file;
write_file_func zwrite_file; tell64_file_func ztell64_file;
tell64_file_func ztell64_file; seek64_file_func zseek64_file;
seek64_file_func zseek64_file; close_file_func zclose_file;
close_file_func zclose_file; testerror_file_func zerror_file;
error_file_func zerror_file; voidpf opaque;
voidpf opaque;
} zlib_filefunc64_def; } zlib_filefunc64_def;
void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def); void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def); void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
/* now internal definition, only for zip.c and unzip.h */ /* now internal definition, only for zip.c and unzip.h */
typedef struct zlib_filefunc64_32_def_s typedef struct zlib_filefunc64_32_def_s
{ {
zlib_filefunc64_def zfile_func64; zlib_filefunc64_def zfile_func64;
open_file_func zopen32_file; open_file_func zopen32_file;
opendisk_file_func zopendisk32_file;
tell_file_func ztell32_file; tell_file_func ztell32_file;
seek_file_func zseek32_file; seek_file_func zseek32_file;
} zlib_filefunc64_32_def; } zlib_filefunc64_32_def;
#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
/*#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))*/
/*#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))*/
#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream))
#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream))
voidpf call_zopen64(const zlib_filefunc64_32_def *pfilefunc,const void*filename, int mode); #define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
voidpf call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode); #define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
long call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin); //#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
uint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream); //#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream))
#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream))
void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32); voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
long call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode))) void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
#define ZOPENDISK64(filefunc,filestream,diskn,mode) (call_zopendisk64((&(filefunc)),(filestream),(diskn),(mode)))
#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream))) #define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode)))
#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode))) #define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream)))
#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
#ifdef __cplusplus #ifdef __cplusplus
} }

3150
contrib/unzip/unzip.c
View File

File diff suppressed because it is too large Load Diff

539
contrib/unzip/unzip.h
View File

@ -1,21 +1,47 @@
/* unzip.h -- IO for uncompress .zip files using zlib /* unzip.h -- IO for uncompress .zip files using zlib
Version 1.1, February 14h, 2010 Version 1.1, February 14h, 2010
part of the MiniZip project part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
Copyright (C) 1998-2010 Gilles Vollant Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
http://www.winimage.com/zLibDll/minizip.html
Modifications of Unzip for Zip64 Modifications of Unzip for Zip64
Copyright (C) 2007-2008 Even Rouault Copyright (C) 2007-2008 Even Rouault
Modifications for Zip64 support on both zip and unzip
Copyright (C) 2009-2010 Mathias Svensson Modifications for Zip64 support on both zip and unzip
http://result42.com Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
For more info read MiniZip_info.txt
---------------------------------------------------------------------------------
Condition of use and distribution are the same than zlib :
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.
---------------------------------------------------------------------------------
Changes
See header of unzip64.c
This program is distributed under the terms of the same license as zlib.
See the accompanying LICENSE file for the full text of the license.
*/ */
#ifndef _UNZ_H #ifndef _unz64_H
#define _UNZ_H #define _unz64_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -25,7 +51,7 @@ extern "C" {
#include "zlib.h" #include "zlib.h"
#endif #endif
#ifndef _ZLIBIOAPI_H #ifndef _ZLIBIOAPI_H
#include "ioapi.h" #include "ioapi.h"
#endif #endif
@ -38,12 +64,13 @@ extern "C" {
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) #if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
/* like the STRICT of WIN32, we define a pointer that cannot be converted /* like the STRICT of WIN32, we define a pointer that cannot be converted
from (void*) without cast */ from (void*) without cast */
typedef struct TagunzFile__ { int unused; } unz_file__; typedef struct TagunzFile__ { int unused; } unzFile__;
typedef unz_file__ *unzFile; typedef unzFile__ *unzFile;
#else #else
typedef voidp unzFile; typedef voidp unzFile;
#endif #endif
#define UNZ_OK (0) #define UNZ_OK (0)
#define UNZ_END_OF_LIST_OF_FILE (-100) #define UNZ_END_OF_LIST_OF_FILE (-100)
#define UNZ_ERRNO (Z_ERRNO) #define UNZ_ERRNO (Z_ERRNO)
@ -52,255 +79,359 @@ typedef voidp unzFile;
#define UNZ_BADZIPFILE (-103) #define UNZ_BADZIPFILE (-103)
#define UNZ_INTERNALERROR (-104) #define UNZ_INTERNALERROR (-104)
#define UNZ_CRCERROR (-105) #define UNZ_CRCERROR (-105)
#define UNZ_BADPASSWORD (-106)
/* tm_unz contain date/time info */
typedef struct tm_unz_s
{
int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */
int tm_mday; /* day of the month - [1,31] */
int tm_mon; /* months since January - [0,11] */
int tm_year; /* years - [1980..2044] */
} tm_unz;
/* unz_global_info structure contain global data about the ZIPfile /* unz_global_info structure contain global data about the ZIPfile
These data comes from the end of central dir */ These data comes from the end of central dir */
typedef struct unz_global_info64_s typedef struct unz_global_info64_s
{ {
uint64_t number_entry; /* total number of entries in the central dir on this disk */ ZPOS64_T number_entry; /* total number of entries in
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/ the central dir on this disk */
uint16_t size_comment; /* size of the global comment of the zipfile */ uLong size_comment; /* size of the global comment of the zipfile */
} unz_global_info64; } unz_global_info64;
typedef struct unz_global_info_s typedef struct unz_global_info_s
{ {
uint32_t number_entry; /* total number of entries in the central dir on this disk */ uLong number_entry; /* total number of entries in
uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/ the central dir on this disk */
uint16_t size_comment; /* size of the global comment of the zipfile */ uLong size_comment; /* size of the global comment of the zipfile */
} unz_global_info; } unz_global_info;
/* unz_file_info contain information about a file in the zipfile */ /* unz_file_info contain information about a file in the zipfile */
typedef struct unz_file_info64_s typedef struct unz_file_info64_s
{ {
uint16_t version; /* version made by 2 bytes */ uLong version; /* version made by 2 bytes */
uint16_t version_needed; /* version needed to extract 2 bytes */ uLong version_needed; /* version needed to extract 2 bytes */
uint16_t flag; /* general purpose bit flag 2 bytes */ uLong flag; /* general purpose bit flag 2 bytes */
uint16_t compression_method; /* compression method 2 bytes */ uLong compression_method; /* compression method 2 bytes */
uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */ uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
uint32_t crc; /* crc-32 4 bytes */ uLong crc; /* crc-32 4 bytes */
uint64_t compressed_size; /* compressed size 8 bytes */ ZPOS64_T compressed_size; /* compressed size 8 bytes */
uint64_t uncompressed_size; /* uncompressed size 8 bytes */ ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */
uint16_t size_filename; /* filename length 2 bytes */ uLong size_filename; /* filename length 2 bytes */
uint16_t size_file_extra; /* extra field length 2 bytes */ uLong size_file_extra; /* extra field length 2 bytes */
uint16_t size_file_comment; /* file comment length 2 bytes */ uLong size_file_comment; /* file comment length 2 bytes */
uint32_t disk_num_start; /* disk number start 4 bytes */ uLong disk_num_start; /* disk number start 2 bytes */
uint16_t internal_fa; /* internal file attributes 2 bytes */ uLong internal_fa; /* internal file attributes 2 bytes */
uint32_t external_fa; /* external file attributes 4 bytes */ uLong external_fa; /* external file attributes 4 bytes */
uint64_t disk_offset; tm_unz tmu_date;
uint16_t size_file_extra_internal;
} unz_file_info64; } unz_file_info64;
typedef struct unz_file_info_s typedef struct unz_file_info_s
{ {
uint16_t version; /* version made by 2 bytes */ uLong version; /* version made by 2 bytes */
uint16_t version_needed; /* version needed to extract 2 bytes */ uLong version_needed; /* version needed to extract 2 bytes */
uint16_t flag; /* general purpose bit flag 2 bytes */ uLong flag; /* general purpose bit flag 2 bytes */
uint16_t compression_method; /* compression method 2 bytes */ uLong compression_method; /* compression method 2 bytes */
uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */ uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
uint32_t crc; /* crc-32 4 bytes */ uLong crc; /* crc-32 4 bytes */
uint32_t compressed_size; /* compressed size 4 bytes */ uLong compressed_size; /* compressed size 4 bytes */
uint32_t uncompressed_size; /* uncompressed size 4 bytes */ uLong uncompressed_size; /* uncompressed size 4 bytes */
uint16_t size_filename; /* filename length 2 bytes */ uLong size_filename; /* filename length 2 bytes */
uint16_t size_file_extra; /* extra field length 2 bytes */ uLong size_file_extra; /* extra field length 2 bytes */
uint16_t size_file_comment; /* file comment length 2 bytes */ uLong size_file_comment; /* file comment length 2 bytes */
uint16_t disk_num_start; /* disk number start 2 bytes */ uLong disk_num_start; /* disk number start 2 bytes */
uint16_t internal_fa; /* internal file attributes 2 bytes */ uLong internal_fa; /* internal file attributes 2 bytes */
uint32_t external_fa; /* external file attributes 4 bytes */ uLong external_fa; /* external file attributes 4 bytes */
uint64_t disk_offset; tm_unz tmu_date;
} unz_file_info; } unz_file_info;
/***************************************************************************/ extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
/* Opening and close a zip file */ const char* fileName2,
int iCaseSensitivity));
/*
Compare two filename (fileName1,fileName2).
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
or strcasecmp)
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
(like 1 on Unix, 2 on Windows)
*/
extern unzFile ZEXPORT unzOpen(const char *path);
extern unzFile ZEXPORT unzOpen64(const void *path);
/* Open a Zip file.
path should contain the full path (by example, on a Windows XP computer extern unzFile ZEXPORT unzOpen OF((const char *path));
"c:\\zlib\\zlib113.zip" or on an Unix computer "zlib/zlib113.zip". extern unzFile ZEXPORT unzOpen64 OF((const void *path));
return NULL if zipfile cannot be opened or doesn't exist /*
return unzFile handle if no error Open a Zip file. path contain the full pathname (by example,
on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
"zlib/zlib113.zip".
If the zipfile cannot be opened (file don't exist or in not valid), the
return value is NULL.
Else, the return value is a unzFile Handle, usable with other function
of this unzip package.
the "64" function take a const void* pointer, because the path is just the
value passed to the open64_file_func callback.
Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path
is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char*
does not describe the reality
*/
NOTE: The "64" function take a const void *pointer, because the path is just the value passed to the
open64_file_func callback. Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path
is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char *does not describe the reality */
extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def); extern unzFile ZEXPORT unzOpen2 OF((const char *path,
/* Open a Zip file, like unzOpen, but provide a set of file low level API for read/write operations */ zlib_filefunc_def* pzlib_filefunc_def));
extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def); /*
/* Open a Zip file, like unz64Open, but provide a set of file low level API for read/write 64-bit operations */ Open a Zip file, like unzOpen, but provide a set of file low level API
for read/write the zip file (see ioapi.h)
*/
extern int ZEXPORT unzClose(unzFile file); extern unzFile ZEXPORT unzOpen2_64 OF((const void *path,
/* Close a ZipFile opened with unzOpen. If there is files inside the .Zip opened with unzOpenCurrentFile, zlib_filefunc64_def* pzlib_filefunc_def));
these files MUST be closed with unzipCloseCurrentFile before call unzipClose. /*
Open a Zip file, like unz64Open, but provide a set of file low level API
for read/write the zip file (see ioapi.h)
*/
return UNZ_OK if there is no error */ extern int ZEXPORT unzClose OF((unzFile file));
/*
Close a ZipFile opened with unzOpen.
If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
these files MUST be closed with unzCloseCurrentFile before call unzClose.
return UNZ_OK if there is no problem. */
extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info); extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info); unz_global_info *pglobal_info));
/* Write info about the ZipFile in the *pglobal_info structure.
return UNZ_OK if no error */ extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file,
unz_global_info64 *pglobal_info));
/*
Write info about the ZipFile in the *pglobal_info structure.
No preparation of the structure is needed
return UNZ_OK if there is no problem. */
extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size);
/* Get the global comment string of the ZipFile, in the comment buffer.
uSizeBuf is the size of the szComment buffer. extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
return the number of byte copied or an error code <0 */ char *szComment,
uLong uSizeBuf));
/*
Get the global comment string of the ZipFile, in the szComment buffer.
uSizeBuf is the size of the szComment buffer.
return the number of byte copied or an error code <0
*/
/***************************************************************************/ /***************************************************************************/
/* Reading the content of the current zipfile, you can open it, read data from it, and close it /* Unzip package allow you browse the directory of the zipfile */
(you can close it before reading all the file) */
extern int ZEXPORT unzOpenCurrentFile(unzFile file); extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
/* Open for reading data the current file in the zipfile. /*
Set the current file of the zipfile to the first file.
return UNZ_OK if there is no problem
*/
return UNZ_OK if no error */ extern int ZEXPORT unzGoToNextFile OF((unzFile file));
/*
Set the current file of the zipfile to the next file.
return UNZ_OK if there is no problem
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
*/
extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password); extern int ZEXPORT unzLocateFile OF((unzFile file,
/* Open for reading data the current file in the zipfile. const char *szFileName,
password is a crypting password int iCaseSensitivity));
/*
Try locate the file szFileName in the zipfile.
For the iCaseSensitivity signification, see unzStringFileNameCompare
return UNZ_OK if no error */ return value :
UNZ_OK if the file is found. It becomes the current file.
UNZ_END_OF_LIST_OF_FILE if the file is not found
*/
extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw);
/* Same as unzOpenCurrentFile, but open for read raw the file (not uncompress)
if raw==1 *method will receive method of compression, *level will receive level of compression
NOTE: you can set level parameter as NULL (if you did not want known level,
but you CANNOT set method parameter as NULL */
extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password);
/* Same as unzOpenCurrentFile, but takes extra parameter password for encrypted files */
extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len);
/* Read bytes from the current file (opened by unzOpenCurrentFile)
buf contain buffer where data must be copied
len the size of buf.
return the number of byte copied if somes bytes are copied
return 0 if the end of file was reached
return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */
extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
/* Get Info about the current file
pfile_info if != NULL, the *pfile_info structure will contain somes info about the current file
filename if != NULL, the file name string will be copied in filename
filename_size is the size of the filename buffer
extrafield if != NULL, the extra field information from the central header will be copied in to
extrafield_size is the size of the extraField buffer
comment if != NULL, the comment string of the file will be copied in to
comment_size is the size of the comment buffer */
extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, uint32_t len);
/* Read extra field from the current file (opened by unzOpenCurrentFile)
This is the local-header version of the extra field (sometimes, there is
more info in the local-header version than in the central-header)
if buf == NULL, it return the size of the local extra field
if buf != NULL, len is the size of the buffer, the extra header is copied in buf.
return number of bytes copied in buf, or (if <0) the error code */
extern int ZEXPORT unzCloseCurrentFile(unzFile file);
/* Close the file in zip opened with unzOpenCurrentFile
return UNZ_CRCERROR if all the file was read but the CRC is not good */
/***************************************************************************/
/* Browse the directory of the zipfile */
typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2);
typedef int (*unzIteratorFunction)(unzFile file);
typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
extern int ZEXPORT unzGoToFirstFile(unzFile file);
/* Set the current file of the zipfile to the first file.
return UNZ_OK if no error */
extern int ZEXPORT unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
/* Set the current file of the zipfile to the first file and retrieves the current info on success.
Not as seek intensive as unzGoToFirstFile + unzGetCurrentFileInfo.
return UNZ_OK if no error */
extern int ZEXPORT unzGoToNextFile(unzFile file);
/* Set the current file of the zipfile to the next file.
return UNZ_OK if no error
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */
extern int ZEXPORT unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename,
uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size);
/* Set the current file of the zipfile to the next file and retrieves the current
info on success. Does less seeking around than unzGotoNextFile + unzGetCurrentFileInfo.
return UNZ_OK if no error
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */
extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func);
/* Try locate the file szFileName in the zipfile. For custom filename comparison pass in comparison function.
return UNZ_OK if the file is found (it becomes the current file)
return UNZ_END_OF_LIST_OF_FILE if the file is not found */
/***************************************************************************/
/* Raw access to zip file */
/* ****************************************** */
/* Ryan supplied functions */
/* unz_file_info contain information about a file in the zipfile */
typedef struct unz_file_pos_s typedef struct unz_file_pos_s
{ {
uint32_t pos_in_zip_directory; /* offset in zip file directory */ uLong pos_in_zip_directory; /* offset in zip file directory */
uint32_t num_of_file; /* # of file */ uLong num_of_file; /* # of file */
} unz_file_pos; } unz_file_pos;
extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos *file_pos); extern int ZEXPORT unzGetFilePos(
extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos *file_pos); unzFile file,
unz_file_pos* file_pos);
extern int ZEXPORT unzGoToFilePos(
unzFile file,
unz_file_pos* file_pos);
typedef struct unz64_file_pos_s typedef struct unz64_file_pos_s
{ {
uint64_t pos_in_zip_directory; /* offset in zip file directory */ ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */
uint64_t num_of_file; /* # of file */ ZPOS64_T num_of_file; /* # of file */
} unz64_file_pos; } unz64_file_pos;
extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos *file_pos); extern int ZEXPORT unzGetFilePos64(
extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos); unzFile file,
unz64_file_pos* file_pos);
extern int32_t ZEXPORT unzGetOffset(unzFile file); extern int ZEXPORT unzGoToFilePos64(
extern int64_t ZEXPORT unzGetOffset64(unzFile file); unzFile file,
/* Get the current file offset */ const unz64_file_pos* file_pos);
extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos); /* ****************************************** */
extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos);
/* Set the current file offset */
extern int32_t ZEXPORT unzTell(unzFile file); extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file,
extern int64_t ZEXPORT unzTell64(unzFile file); unz_file_info64 *pfile_info,
/* return current position in uncompressed data */ char *szFileName,
uLong fileNameBufferSize,
void *extraField,
uLong extraFieldBufferSize,
char *szComment,
uLong commentBufferSize));
extern int ZEXPORT unzSeek(unzFile file, uint32_t offset, int origin); extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
extern int ZEXPORT unzSeek64(unzFile file, uint64_t offset, int origin); unz_file_info *pfile_info,
/* Seek within the uncompressed data if compression method is storage */ char *szFileName,
uLong fileNameBufferSize,
void *extraField,
uLong extraFieldBufferSize,
char *szComment,
uLong commentBufferSize));
/*
Get Info about the current file
if pfile_info!=NULL, the *pfile_info structure will contain somes info about
the current file
if szFileName!=NULL, the filemane string will be copied in szFileName
(fileNameBufferSize is the size of the buffer)
if extraField!=NULL, the extra field information will be copied in extraField
(extraFieldBufferSize is the size of the buffer).
This is the Central-header version of the extra field
if szComment!=NULL, the comment string of the file will be copied in szComment
(commentBufferSize is the size of the buffer)
*/
/** Addition for GDAL : START */
extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file));
/** Addition for GDAL : END */
extern int ZEXPORT unzEndOfFile(unzFile file);
/* return 1 if the end of file was reached, 0 elsewhere */
/***************************************************************************/ /***************************************************************************/
/* for reading the content of the current zipfile, you can open it, read data
from it, and close it (you can close it before reading all the file)
*/
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
/*
Open for reading data the current file in the zipfile.
If there is no error, the return value is UNZ_OK.
*/
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
const char* password));
/*
Open for reading data the current file in the zipfile.
password is a crypting password
If there is no error, the return value is UNZ_OK.
*/
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
int* method,
int* level,
int raw));
/*
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
if raw==1
*method will receive method of compression, *level will receive level of
compression
note : you can set level parameter as NULL (if you did not want known level,
but you CANNOT set method parameter as NULL
*/
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
int* method,
int* level,
int raw,
const char* password));
/*
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
if raw==1
*method will receive method of compression, *level will receive level of
compression
note : you can set level parameter as NULL (if you did not want known level,
but you CANNOT set method parameter as NULL
*/
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
/*
Close the file in zip opened with unzOpenCurrentFile
Return UNZ_CRCERROR if all the file was read but the CRC is not good
*/
extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
voidp buf,
unsigned len));
/*
Read bytes from the current file (opened by unzOpenCurrentFile)
buf contain buffer where data must be copied
len the size of buf.
return the number of byte copied if somes bytes are copied
return 0 if the end of file was reached
return <0 with error code if there is an error
(UNZ_ERRNO for IO error, or zLib error for uncompress error)
*/
extern z_off_t ZEXPORT unztell OF((unzFile file));
extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file));
/*
Give the current position in uncompressed data
*/
extern int ZEXPORT unzeof OF((unzFile file));
/*
return 1 if the end of file was reached, 0 elsewhere
*/
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
voidp buf,
unsigned len));
/*
Read extra field from the current file (opened by unzOpenCurrentFile)
This is the local-header version of the extra field (sometimes, there is
more info in the local-header version than in the central-header)
if buf==NULL, it return the size of the local extra field
if buf!=NULL, len is the size of the buffer, the extra header is copied in
buf.
the return value is the number of bytes copied in buf, or (if <0)
the error code
*/
/***************************************************************************/
/* Get the current file offset */
extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file);
extern uLong ZEXPORT unzGetOffset (unzFile file);
/* Set the current file offset */
extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos);
extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _UNZ_H */ #endif /* _unz64_H */

23
contrib/utf8cpp/doc/LICENSE 100644
View File

@ -0,0 +1,23 @@
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

1503
contrib/utf8cpp/doc/README.md 100644
View File

File diff suppressed because it is too large Load Diff

12
contrib/utf8cpp/doc/ReleaseNotes
View File

@ -1,12 +0,0 @@
utf8 cpp library
Release 2.3.4
A minor bug fix release. Thanks to all who reported bugs.
Note: Version 2.3.3 contained a regression, and therefore was removed.
Changes from version 2.3.2
- Bug fix [39]: checked.h Line 273 and unchecked.h Line 182 have an extra ';'
- Bug fix [36]: replace_invalid() only works with back_inserter
Files included in the release: utf8.h, core.h, checked.h, unchecked.h, utf8cpp.html, ReleaseNotes

1789
contrib/utf8cpp/doc/utf8cpp.html
View File

File diff suppressed because it is too large Load Diff

34
contrib/utf8cpp/source/utf8/checked.h
View File

@ -42,7 +42,7 @@ namespace utf8
uint32_t cp; uint32_t cp;
public: public:
invalid_code_point(uint32_t codepoint) : cp(codepoint) {} invalid_code_point(uint32_t codepoint) : cp(codepoint) {}
virtual const char* what() const NOEXCEPT OVERRIDE { return "Invalid code point"; } virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Invalid code point"; }
uint32_t code_point() const {return cp;} uint32_t code_point() const {return cp;}
}; };
@ -50,7 +50,8 @@ namespace utf8
uint8_t u8; uint8_t u8;
public: public:
invalid_utf8 (uint8_t u) : u8(u) {} invalid_utf8 (uint8_t u) : u8(u) {}
virtual const char* what() const NOEXCEPT OVERRIDE { return "Invalid UTF-8"; } invalid_utf8 (char c) : u8(static_cast<uint8_t>(c)) {}
virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Invalid UTF-8"; }
uint8_t utf8_octet() const {return u8;} uint8_t utf8_octet() const {return u8;}
}; };
@ -58,13 +59,13 @@ namespace utf8
uint16_t u16; uint16_t u16;
public: public:
invalid_utf16 (uint16_t u) : u16(u) {} invalid_utf16 (uint16_t u) : u16(u) {}
virtual const char* what() const NOEXCEPT OVERRIDE { return "Invalid UTF-16"; } virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Invalid UTF-16"; }
uint16_t utf16_word() const {return u16;} uint16_t utf16_word() const {return u16;}
}; };
class not_enough_room : public exception { class not_enough_room : public exception {
public: public:
virtual const char* what() const NOEXCEPT OVERRIDE { return "Not enough space"; } virtual const char* what() const UTF_CPP_NOEXCEPT UTF_CPP_OVERRIDE { return "Not enough space"; }
}; };
/// The library API - functions intended to be called by the users /// The library API - functions intended to be called by the users
@ -75,24 +76,7 @@ namespace utf8
if (!utf8::internal::is_code_point_valid(cp)) if (!utf8::internal::is_code_point_valid(cp))
throw invalid_code_point(cp); throw invalid_code_point(cp);
if (cp < 0x80) // one octet return internal::append(cp, result);
*(result++) = static_cast<uint8_t>(cp);
else if (cp < 0x800) { // two octets
*(result++) = static_cast<uint8_t>((cp >> 6) | 0xc0);
*(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80);
}
else if (cp < 0x10000) { // three octets
*(result++) = static_cast<uint8_t>((cp >> 12) | 0xe0);
*(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
*(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80);
}
else { // four octets
*(result++) = static_cast<uint8_t>((cp >> 18) | 0xf0);
*(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f) | 0x80);
*(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
*(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80);
}
return result;
} }
template <typename octet_iterator, typename output_iterator> template <typename octet_iterator, typename output_iterator>
@ -148,7 +132,7 @@ namespace utf8
case internal::INVALID_LEAD : case internal::INVALID_LEAD :
case internal::INCOMPLETE_SEQUENCE : case internal::INCOMPLETE_SEQUENCE :
case internal::OVERLONG_SEQUENCE : case internal::OVERLONG_SEQUENCE :
throw invalid_utf8(*it); throw invalid_utf8(static_cast<uint8_t>(*it));
case internal::INVALID_CODE_POINT : case internal::INVALID_CODE_POINT :
throw invalid_code_point(cp); throw invalid_code_point(cp);
} }
@ -325,7 +309,9 @@ namespace utf8
} // namespace utf8 } // namespace utf8
#if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later #if UTF_CPP_CPLUSPLUS >= 201703L // C++ 17 or later
#include "cpp17.h"
#elif UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
#include "cpp11.h" #include "cpp11.h"
#endif // C++ 11 or later #endif // C++ 11 or later

57
contrib/utf8cpp/source/utf8/core.h
View File

@ -39,11 +39,11 @@ DEALINGS IN THE SOFTWARE.
#endif #endif
#if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later #if UTF_CPP_CPLUSPLUS >= 201103L // C++ 11 or later
#define OVERRIDE override #define UTF_CPP_OVERRIDE override
#define NOEXCEPT noexcept #define UTF_CPP_NOEXCEPT noexcept
#else // C++ 98/03 #else // C++ 98/03
#define OVERRIDE #define UTF_CPP_OVERRIDE
#define NOEXCEPT throw() #define UTF_CPP_NOEXCEPT throw()
#endif // C++ 11 or later #endif // C++ 11 or later
@ -297,6 +297,55 @@ namespace internal
return utf8::internal::validate_next(it, end, ignored); return utf8::internal::validate_next(it, end, ignored);
} }
// Internal implementation of both checked and unchecked append() function
// This function will be invoked by the overloads below, as they will know
// the octet_type.
template <typename octet_iterator, typename octet_type>
octet_iterator append(uint32_t cp, octet_iterator result) {
if (cp < 0x80) // one octet
*(result++) = static_cast<octet_type>(cp);
else if (cp < 0x800) { // two octets
*(result++) = static_cast<octet_type>((cp >> 6) | 0xc0);
*(result++) = static_cast<octet_type>((cp & 0x3f) | 0x80);
}
else if (cp < 0x10000) { // three octets
*(result++) = static_cast<octet_type>((cp >> 12) | 0xe0);
*(result++) = static_cast<octet_type>(((cp >> 6) & 0x3f) | 0x80);
*(result++) = static_cast<octet_type>((cp & 0x3f) | 0x80);
}
else { // four octets
*(result++) = static_cast<octet_type>((cp >> 18) | 0xf0);
*(result++) = static_cast<octet_type>(((cp >> 12) & 0x3f)| 0x80);
*(result++) = static_cast<octet_type>(((cp >> 6) & 0x3f) | 0x80);
*(result++) = static_cast<octet_type>((cp & 0x3f) | 0x80);
}
return result;
}
// One of the following overloads will be invoked from the API calls
// A simple (but dangerous) case: the caller appends byte(s) to a char array
inline char* append(uint32_t cp, char* result) {
return append<char*, char>(cp, result);
}
// Hopefully, most common case: the caller uses back_inserter
// i.e. append(cp, std::back_inserter(str));
template<typename container_type>
std::back_insert_iterator<container_type> append
(uint32_t cp, std::back_insert_iterator<container_type> result) {
return append<std::back_insert_iterator<container_type>,
typename container_type::value_type>(cp, result);
}
// The caller uses some other kind of output operator - not covered above
// Note that in this case we are not able to determine octet_type
// so we assume it's uint_8; that can cause a conversion warning if we are wrong.
template <typename octet_iterator>
octet_iterator append(uint32_t cp, octet_iterator result) {
return append<octet_iterator, uint8_t>(cp, result);
}
} // namespace internal } // namespace internal
/// The library API - functions intended to be called by the users /// The library API - functions intended to be called by the users

2
contrib/utf8cpp/source/utf8/cpp11.h
View File

@ -70,7 +70,7 @@ namespace utf8
inline std::size_t find_invalid(const std::string& s) inline std::size_t find_invalid(const std::string& s)
{ {
std::string::const_iterator invalid = find_invalid(s.begin(), s.end()); std::string::const_iterator invalid = find_invalid(s.begin(), s.end());
return (invalid == s.end()) ? std::string::npos : (invalid - s.begin()); return (invalid == s.end()) ? std::string::npos : static_cast<std::size_t>(invalid - s.begin());
} }
inline bool is_valid(const std::string& s) inline bool is_valid(const std::string& s)

103
contrib/utf8cpp/source/utf8/cpp17.h 100644
View File

@ -0,0 +1,103 @@
// Copyright 2018 Nemanja Trifunovic
/*
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#ifndef UTF8_FOR_CPP_7e906c01_03a3_4daf_b420_ea7ea952b3c9
#define UTF8_FOR_CPP_7e906c01_03a3_4daf_b420_ea7ea952b3c9
#include "checked.h"
#include <string>
namespace utf8
{
inline void append(char32_t cp, std::string& s)
{
append(uint32_t(cp), std::back_inserter(s));
}
inline std::string utf16to8(std::u16string_view s)
{
std::string result;
utf16to8(s.begin(), s.end(), std::back_inserter(result));
return result;
}
inline std::u16string utf8to16(std::string_view s)
{
std::u16string result;
utf8to16(s.begin(), s.end(), std::back_inserter(result));
return result;
}
inline std::string utf32to8(std::u32string_view s)
{
std::string result;
utf32to8(s.begin(), s.end(), std::back_inserter(result));
return result;
}
inline std::u32string utf8to32(std::string_view s)
{
std::u32string result;
utf8to32(s.begin(), s.end(), std::back_inserter(result));
return result;
}
inline std::size_t find_invalid(std::string_view s)
{
std::string_view::const_iterator invalid = find_invalid(s.begin(), s.end());
return (invalid == s.end()) ? std::string_view::npos : static_cast<std::size_t>(invalid - s.begin());
}
inline bool is_valid(std::string_view s)
{
return is_valid(s.begin(), s.end());
}
inline std::string replace_invalid(std::string_view s, char32_t replacement)
{
std::string result;
replace_invalid(s.begin(), s.end(), std::back_inserter(result), replacement);
return result;
}
inline std::string replace_invalid(std::string_view s)
{
std::string result;
replace_invalid(s.begin(), s.end(), std::back_inserter(result));
return result;
}
inline bool starts_with_bom(std::string_view s)
{
return starts_with_bom(s.begin(), s.end());
}
} // namespace utf8
#endif // header guard

19
contrib/utf8cpp/source/utf8/unchecked.h
View File

@ -37,24 +37,7 @@ namespace utf8
template <typename octet_iterator> template <typename octet_iterator>
octet_iterator append(uint32_t cp, octet_iterator result) octet_iterator append(uint32_t cp, octet_iterator result)
{ {
if (cp < 0x80) // one octet return internal::append(cp, result);
*(result++) = static_cast<uint8_t>(cp);
else if (cp < 0x800) { // two octets
*(result++) = static_cast<uint8_t>((cp >> 6) | 0xc0);
*(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80);
}
else if (cp < 0x10000) { // three octets
*(result++) = static_cast<uint8_t>((cp >> 12) | 0xe0);
*(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
*(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80);
}
else { // four octets
*(result++) = static_cast<uint8_t>((cp >> 18) | 0xf0);
*(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)| 0x80);
*(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
*(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80);
}
return result;
} }
template <typename octet_iterator, typename output_iterator> template <typename octet_iterator, typename output_iterator>

2
contrib/zlib/CMakeLists.txt
View File

@ -10,7 +10,7 @@ endif()
project(zlib C) project(zlib C)
SET (ZLIB_VERSION_MAJOR 1) SET (ZLIB_VERSION_MAJOR 1)
SET (ZLIB_VERSION_MINOR 2) SET (ZLIB_VERSION_MINOR 2)
SET (ZLIB_VERSION_PATCH 11) SET (ZLIB_VERSION_PATCH 13)
SET (ZLIB_VERSION ${ZLIB_VERSION_MAJOR}.${ZLIB_VERSION_MINOR}.${ZLIB_VERSION_PATCH}) SET (ZLIB_VERSION ${ZLIB_VERSION_MAJOR}.${ZLIB_VERSION_MINOR}.${ZLIB_VERSION_PATCH})
SET (ZLIB_SOVERSION 1) SET (ZLIB_SOVERSION 1)
SET (PROJECT_VERSION "${ZLIB_VERSION}") SET (PROJECT_VERSION "${ZLIB_VERSION}")

1590
contrib/zlib/ChangeLog 100644
View File

File diff suppressed because it is too large Load Diff

22
contrib/zlib/LICENSE 100644
View File

@ -0,0 +1,22 @@
Copyright notice:
(C) 1995-2022 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
jloup@gzip.org madler@alumni.caltech.edu

6
contrib/zlib/compress.c
View File

@ -19,7 +19,7 @@
memory, Z_BUF_ERROR if there was not enough room in the output buffer, memory, Z_BUF_ERROR if there was not enough room in the output buffer,
Z_STREAM_ERROR if the level parameter is invalid. Z_STREAM_ERROR if the level parameter is invalid.
*/ */
int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) int ZEXPORT compress2(dest, destLen, source, sourceLen, level)
Bytef *dest; Bytef *dest;
uLongf *destLen; uLongf *destLen;
const Bytef *source; const Bytef *source;
@ -65,7 +65,7 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
/* =========================================================================== /* ===========================================================================
*/ */
int ZEXPORT compress (dest, destLen, source, sourceLen) int ZEXPORT compress(dest, destLen, source, sourceLen)
Bytef *dest; Bytef *dest;
uLongf *destLen; uLongf *destLen;
const Bytef *source; const Bytef *source;
@ -78,7 +78,7 @@ int ZEXPORT compress (dest, destLen, source, sourceLen)
If the default memLevel or windowBits for deflateInit() is changed, then If the default memLevel or windowBits for deflateInit() is changed, then
this function needs to be updated. this function needs to be updated.
*/ */
uLong ZEXPORT compressBound (sourceLen) uLong ZEXPORT compressBound(sourceLen)
uLong sourceLen; uLong sourceLen;
{ {
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +

23
contrib/zlib/contrib/README.contrib
View File

@ -1,4 +1,4 @@
All files under this contrib directory are UNSUPPORTED. There were All files under this contrib directory are UNSUPPORTED. They were
provided by users of zlib and were not tested by the authors of zlib. provided by users of zlib and were not tested by the authors of zlib.
Use at your own risk. Please contact the authors of the contributions Use at your own risk. Please contact the authors of the contributions
for help about these, not the zlib authors. Thanks. for help about these, not the zlib authors. Thanks.
@ -8,14 +8,6 @@ ada/ by Dmitriy Anisimkov <anisimkov@yahoo.com>
Support for Ada Support for Ada
See http://zlib-ada.sourceforge.net/ See http://zlib-ada.sourceforge.net/
amd64/ by Mikhail Teterin <mi@ALDAN.algebra.com>
asm code for AMD64
See patch at http://www.freebsd.org/cgi/query-pr.cgi?pr=bin/96393
asm686/ by Brian Raiter <breadbox@muppetlabs.com>
asm code for Pentium and PPro/PII, using the AT&T (GNU as) syntax
See http://www.muppetlabs.com/~breadbox/software/assembly.html
blast/ by Mark Adler <madler@alumni.caltech.edu> blast/ by Mark Adler <madler@alumni.caltech.edu>
Decompressor for output of PKWare Data Compression Library (DCL) Decompressor for output of PKWare Data Compression Library (DCL)
@ -32,9 +24,6 @@ gcc_gvmat64/by Gilles Vollant <info@winimage.com>
infback9/ by Mark Adler <madler@alumni.caltech.edu> infback9/ by Mark Adler <madler@alumni.caltech.edu>
Unsupported diffs to infback to decode the deflate64 format Unsupported diffs to infback to decode the deflate64 format
inflate86/ by Chris Anderson <christop@charm.net>
Tuned x86 gcc asm code to replace inflate_fast()
iostream/ by Kevin Ruland <kevin@rodin.wustl.edu> iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
A C++ I/O streams interface to the zlib gz* functions A C++ I/O streams interface to the zlib gz* functions
@ -45,16 +34,6 @@ iostream3/ by Ludwig Schwardt <schwardt@sun.ac.za>
and Kevin Ruland <kevin@rodin.wustl.edu> and Kevin Ruland <kevin@rodin.wustl.edu>
Yet another C++ I/O streams interface Yet another C++ I/O streams interface
masmx64/ by Gilles Vollant <info@winimage.com>
x86 64-bit (AMD64 and Intel EM64t) code for x64 assembler to
replace longest_match() and inflate_fast(), also masm x86
64-bits translation of Chris Anderson inflate_fast()
masmx86/ by Gilles Vollant <info@winimage.com>
x86 asm code to replace longest_match() and inflate_fast(),
for Visual C++ and MASM (32 bits).
Based on Brian Raiter (asm686) and Chris Anderson (inflate86)
minizip/ by Gilles Vollant <info@winimage.com> minizip/ by Gilles Vollant <info@winimage.com>
Mini zip and unzip based on zlib Mini zip and unzip based on zlib
Includes Zip64 support by Mathias Svensson <mathias@result42.com> Includes Zip64 support by Mathias Svensson <mathias@result42.com>

2
contrib/zlib/contrib/blast/blast.h
View File

@ -57,7 +57,7 @@ int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow,
* use by the application to pass an input descriptor to infun(), if desired. * use by the application to pass an input descriptor to infun(), if desired.
* *
* If left and in are not NULL and *left is not zero when blast() is called, * If left and in are not NULL and *left is not zero when blast() is called,
* then the *left bytes are *in are consumed for input before infun() is used. * then the *left bytes at *in are consumed for input before infun() is used.
* *
* The output function is invoked: err = outfun(how, buf, len), where the bytes * The output function is invoked: err = outfun(how, buf, len), where the bytes
* to be written are buf[0..len-1]. If err is not zero, then blast() returns * to be written are buf[0..len-1]. If err is not zero, then blast() returns

2
contrib/zlib/contrib/blast/test.txt
View File

@ -1 +1 @@
AIAIAIAIAIAIA AIAIAIAIAIAIA

2
contrib/zlib/contrib/delphi/ZLib.pas
View File

@ -152,7 +152,7 @@ procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
const OutBuf: Pointer; BufSize: Integer); const OutBuf: Pointer; BufSize: Integer);
const const
zlib_version = '1.2.11'; zlib_version = '1.2.13';
type type
EZlibError = class(Exception); EZlibError = class(Exception);

64
contrib/zlib/contrib/dotzlib/DotZLib.build
View File

@ -1,33 +1,33 @@
<?xml version="1.0" encoding="utf-8" ?> <?xml version="1.0" encoding="utf-8" ?>
<project name="DotZLib" default="build" basedir="./DotZLib"> <project name="DotZLib" default="build" basedir="./DotZLib">
<description>A .Net wrapper library around ZLib1.dll</description> <description>A .Net wrapper library around ZLib1.dll</description>
<property name="nunit.location" value="c:/program files/NUnit V2.1/bin" /> <property name="nunit.location" value="c:/program files/NUnit V2.1/bin" />
<property name="build.root" value="bin" /> <property name="build.root" value="bin" />
<property name="debug" value="true" /> <property name="debug" value="true" />
<property name="nunit" value="true" /> <property name="nunit" value="true" />
<property name="build.folder" value="${build.root}/debug/" if="${debug}" /> <property name="build.folder" value="${build.root}/debug/" if="${debug}" />
<property name="build.folder" value="${build.root}/release/" unless="${debug}" /> <property name="build.folder" value="${build.root}/release/" unless="${debug}" />
<target name="clean" description="Remove all generated files"> <target name="clean" description="Remove all generated files">
<delete dir="${build.root}" failonerror="false" /> <delete dir="${build.root}" failonerror="false" />
</target> </target>
<target name="build" description="compiles the source code"> <target name="build" description="compiles the source code">
<mkdir dir="${build.folder}" /> <mkdir dir="${build.folder}" />
<csc target="library" output="${build.folder}DotZLib.dll" debug="${debug}"> <csc target="library" output="${build.folder}DotZLib.dll" debug="${debug}">
<references basedir="${nunit.location}"> <references basedir="${nunit.location}">
<includes if="${nunit}" name="nunit.framework.dll" /> <includes if="${nunit}" name="nunit.framework.dll" />
</references> </references>
<sources> <sources>
<includes name="*.cs" /> <includes name="*.cs" />
<excludes name="UnitTests.cs" unless="${nunit}" /> <excludes name="UnitTests.cs" unless="${nunit}" />
</sources> </sources>
<arg value="/d:nunit" if="${nunit}" /> <arg value="/d:nunit" if="${nunit}" />
</csc> </csc>
</target> </target>
</project> </project>

116
contrib/zlib/contrib/dotzlib/DotZLib/AssemblyInfo.cs
View File

@ -1,58 +1,58 @@
using System.Reflection; using System.Reflection;
using System.Runtime.CompilerServices; using System.Runtime.CompilerServices;
// //
// General Information about an assembly is controlled through the following // General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information // set of attributes. Change these attribute values to modify the information
// associated with an assembly. // associated with an assembly.
// //
[assembly: AssemblyTitle("DotZLib")] [assembly: AssemblyTitle("DotZLib")]
[assembly: AssemblyDescription(".Net bindings for ZLib compression dll 1.2.x")] [assembly: AssemblyDescription(".Net bindings for ZLib compression dll 1.2.x")]
[assembly: AssemblyConfiguration("")] [assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Henrik Ravn")] [assembly: AssemblyCompany("Henrik Ravn")]
[assembly: AssemblyProduct("")] [assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("(c) 2004 by Henrik Ravn")] [assembly: AssemblyCopyright("(c) 2004 by Henrik Ravn")]
[assembly: AssemblyTrademark("")] [assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")] [assembly: AssemblyCulture("")]
// //
// Version information for an assembly consists of the following four values: // Version information for an assembly consists of the following four values:
// //
// Major Version // Major Version
// Minor Version // Minor Version
// Build Number // Build Number
// Revision // Revision
// //
// You can specify all the values or you can default the Revision and Build Numbers // You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below: // by using the '*' as shown below:
[assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyVersion("1.0.*")]
// //
// In order to sign your assembly you must specify a key to use. Refer to the // In order to sign your assembly you must specify a key to use. Refer to the
// Microsoft .NET Framework documentation for more information on assembly signing. // Microsoft .NET Framework documentation for more information on assembly signing.
// //
// Use the attributes below to control which key is used for signing. // Use the attributes below to control which key is used for signing.
// //
// Notes: // Notes:
// (*) If no key is specified, the assembly is not signed. // (*) If no key is specified, the assembly is not signed.
// (*) KeyName refers to a key that has been installed in the Crypto Service // (*) KeyName refers to a key that has been installed in the Crypto Service
// Provider (CSP) on your machine. KeyFile refers to a file which contains // Provider (CSP) on your machine. KeyFile refers to a file which contains
// a key. // a key.
// (*) If the KeyFile and the KeyName values are both specified, the // (*) If the KeyFile and the KeyName values are both specified, the
// following processing occurs: // following processing occurs:
// (1) If the KeyName can be found in the CSP, that key is used. // (1) If the KeyName can be found in the CSP, that key is used.
// (2) If the KeyName does not exist and the KeyFile does exist, the key // (2) If the KeyName does not exist and the KeyFile does exist, the key
// in the KeyFile is installed into the CSP and used. // in the KeyFile is installed into the CSP and used.
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility. // (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
// When specifying the KeyFile, the location of the KeyFile should be // When specifying the KeyFile, the location of the KeyFile should be
// relative to the project output directory which is // relative to the project output directory which is
// %Project Directory%\obj\<configuration>. For example, if your KeyFile is // %Project Directory%\obj\<configuration>. For example, if your KeyFile is
// located in the project directory, you would specify the AssemblyKeyFile // located in the project directory, you would specify the AssemblyKeyFile
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")] // attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework // (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
// documentation for more information on this. // documentation for more information on this.
// //
[assembly: AssemblyDelaySign(false)] [assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")] [assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")] [assembly: AssemblyKeyName("")]

404
contrib/zlib/contrib/dotzlib/DotZLib/ChecksumImpl.cs
View File

@ -1,202 +1,202 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
namespace DotZLib namespace DotZLib
{ {
#region ChecksumGeneratorBase #region ChecksumGeneratorBase
/// <summary> /// <summary>
/// Implements the common functionality needed for all <see cref="ChecksumGenerator"/>s /// Implements the common functionality needed for all <see cref="ChecksumGenerator"/>s
/// </summary> /// </summary>
/// <example></example> /// <example></example>
public abstract class ChecksumGeneratorBase : ChecksumGenerator public abstract class ChecksumGeneratorBase : ChecksumGenerator
{ {
/// <summary> /// <summary>
/// The value of the current checksum /// The value of the current checksum
/// </summary> /// </summary>
protected uint _current; protected uint _current;
/// <summary> /// <summary>
/// Initializes a new instance of the checksum generator base - the current checksum is /// Initializes a new instance of the checksum generator base - the current checksum is
/// set to zero /// set to zero
/// </summary> /// </summary>
public ChecksumGeneratorBase() public ChecksumGeneratorBase()
{ {
_current = 0; _current = 0;
} }
/// <summary> /// <summary>
/// Initializes a new instance of the checksum generator basewith a specified value /// Initializes a new instance of the checksum generator basewith a specified value
/// </summary> /// </summary>
/// <param name="initialValue">The value to set the current checksum to</param> /// <param name="initialValue">The value to set the current checksum to</param>
public ChecksumGeneratorBase(uint initialValue) public ChecksumGeneratorBase(uint initialValue)
{ {
_current = initialValue; _current = initialValue;
} }
/// <summary> /// <summary>
/// Resets the current checksum to zero /// Resets the current checksum to zero
/// </summary> /// </summary>
public void Reset() { _current = 0; } public void Reset() { _current = 0; }
/// <summary> /// <summary>
/// Gets the current checksum value /// Gets the current checksum value
/// </summary> /// </summary>
public uint Value { get { return _current; } } public uint Value { get { return _current; } }
/// <summary> /// <summary>
/// Updates the current checksum with part of an array of bytes /// Updates the current checksum with part of an array of bytes
/// </summary> /// </summary>
/// <param name="data">The data to update the checksum with</param> /// <param name="data">The data to update the checksum with</param>
/// <param name="offset">Where in <c>data</c> to start updating</param> /// <param name="offset">Where in <c>data</c> to start updating</param>
/// <param name="count">The number of bytes from <c>data</c> to use</param> /// <param name="count">The number of bytes from <c>data</c> to use</param>
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception> /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
/// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception> /// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception> /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
/// <remarks>All the other <c>Update</c> methods are implmeneted in terms of this one. /// <remarks>All the other <c>Update</c> methods are implmeneted in terms of this one.
/// This is therefore the only method a derived class has to implement</remarks> /// This is therefore the only method a derived class has to implement</remarks>
public abstract void Update(byte[] data, int offset, int count); public abstract void Update(byte[] data, int offset, int count);
/// <summary> /// <summary>
/// Updates the current checksum with an array of bytes. /// Updates the current checksum with an array of bytes.
/// </summary> /// </summary>
/// <param name="data">The data to update the checksum with</param> /// <param name="data">The data to update the checksum with</param>
public void Update(byte[] data) public void Update(byte[] data)
{ {
Update(data, 0, data.Length); Update(data, 0, data.Length);
} }
/// <summary> /// <summary>
/// Updates the current checksum with the data from a string /// Updates the current checksum with the data from a string
/// </summary> /// </summary>
/// <param name="data">The string to update the checksum with</param> /// <param name="data">The string to update the checksum with</param>
/// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks> /// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
public void Update(string data) public void Update(string data)
{ {
Update(Encoding.UTF8.GetBytes(data)); Update(Encoding.UTF8.GetBytes(data));
} }
/// <summary> /// <summary>
/// Updates the current checksum with the data from a string, using a specific encoding /// Updates the current checksum with the data from a string, using a specific encoding
/// </summary> /// </summary>
/// <param name="data">The string to update the checksum with</param> /// <param name="data">The string to update the checksum with</param>
/// <param name="encoding">The encoding to use</param> /// <param name="encoding">The encoding to use</param>
public void Update(string data, Encoding encoding) public void Update(string data, Encoding encoding)
{ {
Update(encoding.GetBytes(data)); Update(encoding.GetBytes(data));
} }
} }
#endregion #endregion
#region CRC32 #region CRC32
/// <summary> /// <summary>
/// Implements a CRC32 checksum generator /// Implements a CRC32 checksum generator
/// </summary> /// </summary>
public sealed class CRC32Checksum : ChecksumGeneratorBase public sealed class CRC32Checksum : ChecksumGeneratorBase
{ {
#region DLL imports #region DLL imports
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern uint crc32(uint crc, int data, uint length); private static extern uint crc32(uint crc, int data, uint length);
#endregion #endregion
/// <summary> /// <summary>
/// Initializes a new instance of the CRC32 checksum generator /// Initializes a new instance of the CRC32 checksum generator
/// </summary> /// </summary>
public CRC32Checksum() : base() {} public CRC32Checksum() : base() {}
/// <summary> /// <summary>
/// Initializes a new instance of the CRC32 checksum generator with a specified value /// Initializes a new instance of the CRC32 checksum generator with a specified value
/// </summary> /// </summary>
/// <param name="initialValue">The value to set the current checksum to</param> /// <param name="initialValue">The value to set the current checksum to</param>
public CRC32Checksum(uint initialValue) : base(initialValue) {} public CRC32Checksum(uint initialValue) : base(initialValue) {}
/// <summary> /// <summary>
/// Updates the current checksum with part of an array of bytes /// Updates the current checksum with part of an array of bytes
/// </summary> /// </summary>
/// <param name="data">The data to update the checksum with</param> /// <param name="data">The data to update the checksum with</param>
/// <param name="offset">Where in <c>data</c> to start updating</param> /// <param name="offset">Where in <c>data</c> to start updating</param>
/// <param name="count">The number of bytes from <c>data</c> to use</param> /// <param name="count">The number of bytes from <c>data</c> to use</param>
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception> /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
/// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception> /// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception> /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
public override void Update(byte[] data, int offset, int count) public override void Update(byte[] data, int offset, int count)
{ {
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException(); if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
if ((offset+count) > data.Length) throw new ArgumentException(); if ((offset+count) > data.Length) throw new ArgumentException();
GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned); GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned);
try try
{ {
_current = crc32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count); _current = crc32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count);
} }
finally finally
{ {
hData.Free(); hData.Free();
} }
} }
} }
#endregion #endregion
#region Adler #region Adler
/// <summary> /// <summary>
/// Implements a checksum generator that computes the Adler checksum on data /// Implements a checksum generator that computes the Adler checksum on data
/// </summary> /// </summary>
public sealed class AdlerChecksum : ChecksumGeneratorBase public sealed class AdlerChecksum : ChecksumGeneratorBase
{ {
#region DLL imports #region DLL imports
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern uint adler32(uint adler, int data, uint length); private static extern uint adler32(uint adler, int data, uint length);
#endregion #endregion
/// <summary> /// <summary>
/// Initializes a new instance of the Adler checksum generator /// Initializes a new instance of the Adler checksum generator
/// </summary> /// </summary>
public AdlerChecksum() : base() {} public AdlerChecksum() : base() {}
/// <summary> /// <summary>
/// Initializes a new instance of the Adler checksum generator with a specified value /// Initializes a new instance of the Adler checksum generator with a specified value
/// </summary> /// </summary>
/// <param name="initialValue">The value to set the current checksum to</param> /// <param name="initialValue">The value to set the current checksum to</param>
public AdlerChecksum(uint initialValue) : base(initialValue) {} public AdlerChecksum(uint initialValue) : base(initialValue) {}
/// <summary> /// <summary>
/// Updates the current checksum with part of an array of bytes /// Updates the current checksum with part of an array of bytes
/// </summary> /// </summary>
/// <param name="data">The data to update the checksum with</param> /// <param name="data">The data to update the checksum with</param>
/// <param name="offset">Where in <c>data</c> to start updating</param> /// <param name="offset">Where in <c>data</c> to start updating</param>
/// <param name="count">The number of bytes from <c>data</c> to use</param> /// <param name="count">The number of bytes from <c>data</c> to use</param>
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception> /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
/// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception> /// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception> /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
public override void Update(byte[] data, int offset, int count) public override void Update(byte[] data, int offset, int count)
{ {
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException(); if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
if ((offset+count) > data.Length) throw new ArgumentException(); if ((offset+count) > data.Length) throw new ArgumentException();
GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned); GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned);
try try
{ {
_current = adler32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count); _current = adler32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count);
} }
finally finally
{ {
hData.Free(); hData.Free();
} }
} }
} }
#endregion #endregion
} }

166
contrib/zlib/contrib/dotzlib/DotZLib/CircularBuffer.cs
View File

@ -1,83 +1,83 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.Diagnostics; using System.Diagnostics;
namespace DotZLib namespace DotZLib
{ {
/// <summary> /// <summary>
/// This class implements a circular buffer /// This class implements a circular buffer
/// </summary> /// </summary>
internal class CircularBuffer internal class CircularBuffer
{ {
#region Private data #region Private data
private int _capacity; private int _capacity;
private int _head; private int _head;
private int _tail; private int _tail;
private int _size; private int _size;
private byte[] _buffer; private byte[] _buffer;
#endregion #endregion
public CircularBuffer(int capacity) public CircularBuffer(int capacity)
{ {
Debug.Assert( capacity > 0 ); Debug.Assert( capacity > 0 );
_buffer = new byte[capacity]; _buffer = new byte[capacity];
_capacity = capacity; _capacity = capacity;
_head = 0; _head = 0;
_tail = 0; _tail = 0;
_size = 0; _size = 0;
} }
public int Size { get { return _size; } } public int Size { get { return _size; } }
public int Put(byte[] source, int offset, int count) public int Put(byte[] source, int offset, int count)
{ {
Debug.Assert( count > 0 ); Debug.Assert( count > 0 );
int trueCount = Math.Min(count, _capacity - Size); int trueCount = Math.Min(count, _capacity - Size);
for (int i = 0; i < trueCount; ++i) for (int i = 0; i < trueCount; ++i)
_buffer[(_tail+i) % _capacity] = source[offset+i]; _buffer[(_tail+i) % _capacity] = source[offset+i];
_tail += trueCount; _tail += trueCount;
_tail %= _capacity; _tail %= _capacity;
_size += trueCount; _size += trueCount;
return trueCount; return trueCount;
} }
public bool Put(byte b) public bool Put(byte b)
{ {
if (Size == _capacity) // no room if (Size == _capacity) // no room
return false; return false;
_buffer[_tail++] = b; _buffer[_tail++] = b;
_tail %= _capacity; _tail %= _capacity;
++_size; ++_size;
return true; return true;
} }
public int Get(byte[] destination, int offset, int count) public int Get(byte[] destination, int offset, int count)
{ {
int trueCount = Math.Min(count,Size); int trueCount = Math.Min(count,Size);
for (int i = 0; i < trueCount; ++i) for (int i = 0; i < trueCount; ++i)
destination[offset + i] = _buffer[(_head+i) % _capacity]; destination[offset + i] = _buffer[(_head+i) % _capacity];
_head += trueCount; _head += trueCount;
_head %= _capacity; _head %= _capacity;
_size -= trueCount; _size -= trueCount;
return trueCount; return trueCount;
} }
public int Get() public int Get()
{ {
if (Size == 0) if (Size == 0)
return -1; return -1;
int result = (int)_buffer[_head++ % _capacity]; int result = (int)_buffer[_head++ % _capacity];
--_size; --_size;
return result; return result;
} }
} }
} }

396
contrib/zlib/contrib/dotzlib/DotZLib/CodecBase.cs
View File

@ -1,198 +1,198 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace DotZLib namespace DotZLib
{ {
/// <summary> /// <summary>
/// Implements the common functionality needed for all <see cref="Codec"/>s /// Implements the common functionality needed for all <see cref="Codec"/>s
/// </summary> /// </summary>
public abstract class CodecBase : Codec, IDisposable public abstract class CodecBase : Codec, IDisposable
{ {
#region Data members #region Data members
/// <summary> /// <summary>
/// Instance of the internal zlib buffer structure that is /// Instance of the internal zlib buffer structure that is
/// passed to all functions in the zlib dll /// passed to all functions in the zlib dll
/// </summary> /// </summary>
internal ZStream _ztream = new ZStream(); internal ZStream _ztream = new ZStream();
/// <summary> /// <summary>
/// True if the object instance has been disposed, false otherwise /// True if the object instance has been disposed, false otherwise
/// </summary> /// </summary>
protected bool _isDisposed = false; protected bool _isDisposed = false;
/// <summary> /// <summary>
/// The size of the internal buffers /// The size of the internal buffers
/// </summary> /// </summary>
protected const int kBufferSize = 16384; protected const int kBufferSize = 16384;
private byte[] _outBuffer = new byte[kBufferSize]; private byte[] _outBuffer = new byte[kBufferSize];
private byte[] _inBuffer = new byte[kBufferSize]; private byte[] _inBuffer = new byte[kBufferSize];
private GCHandle _hInput; private GCHandle _hInput;
private GCHandle _hOutput; private GCHandle _hOutput;
private uint _checksum = 0; private uint _checksum = 0;
#endregion #endregion
/// <summary> /// <summary>
/// Initializes a new instance of the <c>CodeBase</c> class. /// Initializes a new instance of the <c>CodeBase</c> class.
/// </summary> /// </summary>
public CodecBase() public CodecBase()
{ {
try try
{ {
_hInput = GCHandle.Alloc(_inBuffer, GCHandleType.Pinned); _hInput = GCHandle.Alloc(_inBuffer, GCHandleType.Pinned);
_hOutput = GCHandle.Alloc(_outBuffer, GCHandleType.Pinned); _hOutput = GCHandle.Alloc(_outBuffer, GCHandleType.Pinned);
} }
catch (Exception) catch (Exception)
{ {
CleanUp(false); CleanUp(false);
throw; throw;
} }
} }
#region Codec Members #region Codec Members
/// <summary> /// <summary>
/// Occurs when more processed data are available. /// Occurs when more processed data are available.
/// </summary> /// </summary>
public event DataAvailableHandler DataAvailable; public event DataAvailableHandler DataAvailable;
/// <summary> /// <summary>
/// Fires the <see cref="DataAvailable"/> event /// Fires the <see cref="DataAvailable"/> event
/// </summary> /// </summary>
protected void OnDataAvailable() protected void OnDataAvailable()
{ {
if (_ztream.total_out > 0) if (_ztream.total_out > 0)
{ {
if (DataAvailable != null) if (DataAvailable != null)
DataAvailable( _outBuffer, 0, (int)_ztream.total_out); DataAvailable( _outBuffer, 0, (int)_ztream.total_out);
resetOutput(); resetOutput();
} }
} }
/// <summary> /// <summary>
/// Adds more data to the codec to be processed. /// Adds more data to the codec to be processed.
/// </summary> /// </summary>
/// <param name="data">Byte array containing the data to be added to the codec</param> /// <param name="data">Byte array containing the data to be added to the codec</param>
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks> /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
public void Add(byte[] data) public void Add(byte[] data)
{ {
Add(data,0,data.Length); Add(data,0,data.Length);
} }
/// <summary> /// <summary>
/// Adds more data to the codec to be processed. /// Adds more data to the codec to be processed.
/// </summary> /// </summary>
/// <param name="data">Byte array containing the data to be added to the codec</param> /// <param name="data">Byte array containing the data to be added to the codec</param>
/// <param name="offset">The index of the first byte to add from <c>data</c></param> /// <param name="offset">The index of the first byte to add from <c>data</c></param>
/// <param name="count">The number of bytes to add</param> /// <param name="count">The number of bytes to add</param>
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks> /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
/// <remarks>This must be implemented by a derived class</remarks> /// <remarks>This must be implemented by a derived class</remarks>
public abstract void Add(byte[] data, int offset, int count); public abstract void Add(byte[] data, int offset, int count);
/// <summary> /// <summary>
/// Finishes up any pending data that needs to be processed and handled. /// Finishes up any pending data that needs to be processed and handled.
/// </summary> /// </summary>
/// <remarks>This must be implemented by a derived class</remarks> /// <remarks>This must be implemented by a derived class</remarks>
public abstract void Finish(); public abstract void Finish();
/// <summary> /// <summary>
/// Gets the checksum of the data that has been added so far /// Gets the checksum of the data that has been added so far
/// </summary> /// </summary>
public uint Checksum { get { return _checksum; } } public uint Checksum { get { return _checksum; } }
#endregion #endregion
#region Destructor & IDisposable stuff #region Destructor & IDisposable stuff
/// <summary> /// <summary>
/// Destroys this instance /// Destroys this instance
/// </summary> /// </summary>
~CodecBase() ~CodecBase()
{ {
CleanUp(false); CleanUp(false);
} }
/// <summary> /// <summary>
/// Releases any unmanaged resources and calls the <see cref="CleanUp()"/> method of the derived class /// Releases any unmanaged resources and calls the <see cref="CleanUp()"/> method of the derived class
/// </summary> /// </summary>
public void Dispose() public void Dispose()
{ {
CleanUp(true); CleanUp(true);
} }
/// <summary> /// <summary>
/// Performs any codec specific cleanup /// Performs any codec specific cleanup
/// </summary> /// </summary>
/// <remarks>This must be implemented by a derived class</remarks> /// <remarks>This must be implemented by a derived class</remarks>
protected abstract void CleanUp(); protected abstract void CleanUp();
// performs the release of the handles and calls the dereived CleanUp() // performs the release of the handles and calls the dereived CleanUp()
private void CleanUp(bool isDisposing) private void CleanUp(bool isDisposing)
{ {
if (!_isDisposed) if (!_isDisposed)
{ {
CleanUp(); CleanUp();
if (_hInput.IsAllocated) if (_hInput.IsAllocated)
_hInput.Free(); _hInput.Free();
if (_hOutput.IsAllocated) if (_hOutput.IsAllocated)
_hOutput.Free(); _hOutput.Free();
_isDisposed = true; _isDisposed = true;
} }
} }
#endregion #endregion
#region Helper methods #region Helper methods
/// <summary> /// <summary>
/// Copies a number of bytes to the internal codec buffer - ready for proccesing /// Copies a number of bytes to the internal codec buffer - ready for proccesing
/// </summary> /// </summary>
/// <param name="data">The byte array that contains the data to copy</param> /// <param name="data">The byte array that contains the data to copy</param>
/// <param name="startIndex">The index of the first byte to copy</param> /// <param name="startIndex">The index of the first byte to copy</param>
/// <param name="count">The number of bytes to copy from <c>data</c></param> /// <param name="count">The number of bytes to copy from <c>data</c></param>
protected void copyInput(byte[] data, int startIndex, int count) protected void copyInput(byte[] data, int startIndex, int count)
{ {
Array.Copy(data, startIndex, _inBuffer,0, count); Array.Copy(data, startIndex, _inBuffer,0, count);
_ztream.next_in = _hInput.AddrOfPinnedObject(); _ztream.next_in = _hInput.AddrOfPinnedObject();
_ztream.total_in = 0; _ztream.total_in = 0;
_ztream.avail_in = (uint)count; _ztream.avail_in = (uint)count;
} }
/// <summary> /// <summary>
/// Resets the internal output buffers to a known state - ready for processing /// Resets the internal output buffers to a known state - ready for processing
/// </summary> /// </summary>
protected void resetOutput() protected void resetOutput()
{ {
_ztream.total_out = 0; _ztream.total_out = 0;
_ztream.avail_out = kBufferSize; _ztream.avail_out = kBufferSize;
_ztream.next_out = _hOutput.AddrOfPinnedObject(); _ztream.next_out = _hOutput.AddrOfPinnedObject();
} }
/// <summary> /// <summary>
/// Updates the running checksum property /// Updates the running checksum property
/// </summary> /// </summary>
/// <param name="newSum">The new checksum value</param> /// <param name="newSum">The new checksum value</param>
protected void setChecksum(uint newSum) protected void setChecksum(uint newSum)
{ {
_checksum = newSum; _checksum = newSum;
} }
#endregion #endregion
} }
} }

212
contrib/zlib/contrib/dotzlib/DotZLib/Deflater.cs
View File

@ -1,106 +1,106 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace DotZLib namespace DotZLib
{ {
/// <summary> /// <summary>
/// Implements a data compressor, using the deflate algorithm in the ZLib dll /// Implements a data compressor, using the deflate algorithm in the ZLib dll
/// </summary> /// </summary>
public sealed class Deflater : CodecBase public sealed class Deflater : CodecBase
{ {
#region Dll imports #region Dll imports
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
private static extern int deflateInit_(ref ZStream sz, int level, string vs, int size); private static extern int deflateInit_(ref ZStream sz, int level, string vs, int size);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int deflate(ref ZStream sz, int flush); private static extern int deflate(ref ZStream sz, int flush);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int deflateReset(ref ZStream sz); private static extern int deflateReset(ref ZStream sz);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int deflateEnd(ref ZStream sz); private static extern int deflateEnd(ref ZStream sz);
#endregion #endregion
/// <summary> /// <summary>
/// Constructs an new instance of the <c>Deflater</c> /// Constructs an new instance of the <c>Deflater</c>
/// </summary> /// </summary>
/// <param name="level">The compression level to use for this <c>Deflater</c></param> /// <param name="level">The compression level to use for this <c>Deflater</c></param>
public Deflater(CompressLevel level) : base() public Deflater(CompressLevel level) : base()
{ {
int retval = deflateInit_(ref _ztream, (int)level, Info.Version, Marshal.SizeOf(_ztream)); int retval = deflateInit_(ref _ztream, (int)level, Info.Version, Marshal.SizeOf(_ztream));
if (retval != 0) if (retval != 0)
throw new ZLibException(retval, "Could not initialize deflater"); throw new ZLibException(retval, "Could not initialize deflater");
resetOutput(); resetOutput();
} }
/// <summary> /// <summary>
/// Adds more data to the codec to be processed. /// Adds more data to the codec to be processed.
/// </summary> /// </summary>
/// <param name="data">Byte array containing the data to be added to the codec</param> /// <param name="data">Byte array containing the data to be added to the codec</param>
/// <param name="offset">The index of the first byte to add from <c>data</c></param> /// <param name="offset">The index of the first byte to add from <c>data</c></param>
/// <param name="count">The number of bytes to add</param> /// <param name="count">The number of bytes to add</param>
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks> /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
public override void Add(byte[] data, int offset, int count) public override void Add(byte[] data, int offset, int count)
{ {
if (data == null) throw new ArgumentNullException(); if (data == null) throw new ArgumentNullException();
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException(); if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
if ((offset+count) > data.Length) throw new ArgumentException(); if ((offset+count) > data.Length) throw new ArgumentException();
int total = count; int total = count;
int inputIndex = offset; int inputIndex = offset;
int err = 0; int err = 0;
while (err >= 0 && inputIndex < total) while (err >= 0 && inputIndex < total)
{ {
copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize)); copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize));
while (err >= 0 && _ztream.avail_in > 0) while (err >= 0 && _ztream.avail_in > 0)
{ {
err = deflate(ref _ztream, (int)FlushTypes.None); err = deflate(ref _ztream, (int)FlushTypes.None);
if (err == 0) if (err == 0)
while (_ztream.avail_out == 0) while (_ztream.avail_out == 0)
{ {
OnDataAvailable(); OnDataAvailable();
err = deflate(ref _ztream, (int)FlushTypes.None); err = deflate(ref _ztream, (int)FlushTypes.None);
} }
inputIndex += (int)_ztream.total_in; inputIndex += (int)_ztream.total_in;
} }
} }
setChecksum( _ztream.adler ); setChecksum( _ztream.adler );
} }
/// <summary> /// <summary>
/// Finishes up any pending data that needs to be processed and handled. /// Finishes up any pending data that needs to be processed and handled.
/// </summary> /// </summary>
public override void Finish() public override void Finish()
{ {
int err; int err;
do do
{ {
err = deflate(ref _ztream, (int)FlushTypes.Finish); err = deflate(ref _ztream, (int)FlushTypes.Finish);
OnDataAvailable(); OnDataAvailable();
} }
while (err == 0); while (err == 0);
setChecksum( _ztream.adler ); setChecksum( _ztream.adler );
deflateReset(ref _ztream); deflateReset(ref _ztream);
resetOutput(); resetOutput();
} }
/// <summary> /// <summary>
/// Closes the internal zlib deflate stream /// Closes the internal zlib deflate stream
/// </summary> /// </summary>
protected override void CleanUp() { deflateEnd(ref _ztream); } protected override void CleanUp() { deflateEnd(ref _ztream); }
} }
} }

576
contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.cs
View File

@ -1,288 +1,288 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.IO; using System.IO;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
namespace DotZLib namespace DotZLib
{ {
#region Internal types #region Internal types
/// <summary> /// <summary>
/// Defines constants for the various flush types used with zlib /// Defines constants for the various flush types used with zlib
/// </summary> /// </summary>
internal enum FlushTypes internal enum FlushTypes
{ {
None, Partial, Sync, Full, Finish, Block None, Partial, Sync, Full, Finish, Block
} }
#region ZStream structure #region ZStream structure
// internal mapping of the zlib zstream structure for marshalling // internal mapping of the zlib zstream structure for marshalling
[StructLayoutAttribute(LayoutKind.Sequential, Pack=4, Size=0, CharSet=CharSet.Ansi)] [StructLayoutAttribute(LayoutKind.Sequential, Pack=4, Size=0, CharSet=CharSet.Ansi)]
internal struct ZStream internal struct ZStream
{ {
public IntPtr next_in; public IntPtr next_in;
public uint avail_in; public uint avail_in;
public uint total_in; public uint total_in;
public IntPtr next_out; public IntPtr next_out;
public uint avail_out; public uint avail_out;
public uint total_out; public uint total_out;
[MarshalAs(UnmanagedType.LPStr)] [MarshalAs(UnmanagedType.LPStr)]
string msg; string msg;
uint state; uint state;
uint zalloc; uint zalloc;
uint zfree; uint zfree;
uint opaque; uint opaque;
int data_type; int data_type;
public uint adler; public uint adler;
uint reserved; uint reserved;
} }
#endregion #endregion
#endregion #endregion
#region Public enums #region Public enums
/// <summary> /// <summary>
/// Defines constants for the available compression levels in zlib /// Defines constants for the available compression levels in zlib
/// </summary> /// </summary>
public enum CompressLevel : int public enum CompressLevel : int
{ {
/// <summary> /// <summary>
/// The default compression level with a reasonable compromise between compression and speed /// The default compression level with a reasonable compromise between compression and speed
/// </summary> /// </summary>
Default = -1, Default = -1,
/// <summary> /// <summary>
/// No compression at all. The data are passed straight through. /// No compression at all. The data are passed straight through.
/// </summary> /// </summary>
None = 0, None = 0,
/// <summary> /// <summary>
/// The maximum compression rate available. /// The maximum compression rate available.
/// </summary> /// </summary>
Best = 9, Best = 9,
/// <summary> /// <summary>
/// The fastest available compression level. /// The fastest available compression level.
/// </summary> /// </summary>
Fastest = 1 Fastest = 1
} }
#endregion #endregion
#region Exception classes #region Exception classes
/// <summary> /// <summary>
/// The exception that is thrown when an error occurs on the zlib dll /// The exception that is thrown when an error occurs on the zlib dll
/// </summary> /// </summary>
public class ZLibException : ApplicationException public class ZLibException : ApplicationException
{ {
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="ZLibException"/> class with a specified /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
/// error message and error code /// error message and error code
/// </summary> /// </summary>
/// <param name="errorCode">The zlib error code that caused the exception</param> /// <param name="errorCode">The zlib error code that caused the exception</param>
/// <param name="msg">A message that (hopefully) describes the error</param> /// <param name="msg">A message that (hopefully) describes the error</param>
public ZLibException(int errorCode, string msg) : base(String.Format("ZLib error {0} {1}", errorCode, msg)) public ZLibException(int errorCode, string msg) : base(String.Format("ZLib error {0} {1}", errorCode, msg))
{ {
} }
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="ZLibException"/> class with a specified /// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
/// error code /// error code
/// </summary> /// </summary>
/// <param name="errorCode">The zlib error code that caused the exception</param> /// <param name="errorCode">The zlib error code that caused the exception</param>
public ZLibException(int errorCode) : base(String.Format("ZLib error {0}", errorCode)) public ZLibException(int errorCode) : base(String.Format("ZLib error {0}", errorCode))
{ {
} }
} }
#endregion #endregion
#region Interfaces #region Interfaces
/// <summary> /// <summary>
/// Declares methods and properties that enables a running checksum to be calculated /// Declares methods and properties that enables a running checksum to be calculated
/// </summary> /// </summary>
public interface ChecksumGenerator public interface ChecksumGenerator
{ {
/// <summary> /// <summary>
/// Gets the current value of the checksum /// Gets the current value of the checksum
/// </summary> /// </summary>
uint Value { get; } uint Value { get; }
/// <summary> /// <summary>
/// Clears the current checksum to 0 /// Clears the current checksum to 0
/// </summary> /// </summary>
void Reset(); void Reset();
/// <summary> /// <summary>
/// Updates the current checksum with an array of bytes /// Updates the current checksum with an array of bytes
/// </summary> /// </summary>
/// <param name="data">The data to update the checksum with</param> /// <param name="data">The data to update the checksum with</param>
void Update(byte[] data); void Update(byte[] data);
/// <summary> /// <summary>
/// Updates the current checksum with part of an array of bytes /// Updates the current checksum with part of an array of bytes
/// </summary> /// </summary>
/// <param name="data">The data to update the checksum with</param> /// <param name="data">The data to update the checksum with</param>
/// <param name="offset">Where in <c>data</c> to start updating</param> /// <param name="offset">Where in <c>data</c> to start updating</param>
/// <param name="count">The number of bytes from <c>data</c> to use</param> /// <param name="count">The number of bytes from <c>data</c> to use</param>
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception> /// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
/// <exception cref="ArgumentNullException"><c>data</c> is a null reference</exception> /// <exception cref="ArgumentNullException"><c>data</c> is a null reference</exception>
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception> /// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
void Update(byte[] data, int offset, int count); void Update(byte[] data, int offset, int count);
/// <summary> /// <summary>
/// Updates the current checksum with the data from a string /// Updates the current checksum with the data from a string
/// </summary> /// </summary>
/// <param name="data">The string to update the checksum with</param> /// <param name="data">The string to update the checksum with</param>
/// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks> /// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
void Update(string data); void Update(string data);
/// <summary> /// <summary>
/// Updates the current checksum with the data from a string, using a specific encoding /// Updates the current checksum with the data from a string, using a specific encoding
/// </summary> /// </summary>
/// <param name="data">The string to update the checksum with</param> /// <param name="data">The string to update the checksum with</param>
/// <param name="encoding">The encoding to use</param> /// <param name="encoding">The encoding to use</param>
void Update(string data, Encoding encoding); void Update(string data, Encoding encoding);
} }
/// <summary> /// <summary>
/// Represents the method that will be called from a codec when new data /// Represents the method that will be called from a codec when new data
/// are available. /// are available.
/// </summary> /// </summary>
/// <paramref name="data">The byte array containing the processed data</paramref> /// <paramref name="data">The byte array containing the processed data</paramref>
/// <paramref name="startIndex">The index of the first processed byte in <c>data</c></paramref> /// <paramref name="startIndex">The index of the first processed byte in <c>data</c></paramref>
/// <paramref name="count">The number of processed bytes available</paramref> /// <paramref name="count">The number of processed bytes available</paramref>
/// <remarks>On return from this method, the data may be overwritten, so grab it while you can. /// <remarks>On return from this method, the data may be overwritten, so grab it while you can.
/// You cannot assume that startIndex will be zero. /// You cannot assume that startIndex will be zero.
/// </remarks> /// </remarks>
public delegate void DataAvailableHandler(byte[] data, int startIndex, int count); public delegate void DataAvailableHandler(byte[] data, int startIndex, int count);
/// <summary> /// <summary>
/// Declares methods and events for implementing compressors/decompressors /// Declares methods and events for implementing compressors/decompressors
/// </summary> /// </summary>
public interface Codec public interface Codec
{ {
/// <summary> /// <summary>
/// Occurs when more processed data are available. /// Occurs when more processed data are available.
/// </summary> /// </summary>
event DataAvailableHandler DataAvailable; event DataAvailableHandler DataAvailable;
/// <summary> /// <summary>
/// Adds more data to the codec to be processed. /// Adds more data to the codec to be processed.
/// </summary> /// </summary>
/// <param name="data">Byte array containing the data to be added to the codec</param> /// <param name="data">Byte array containing the data to be added to the codec</param>
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks> /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
void Add(byte[] data); void Add(byte[] data);
/// <summary> /// <summary>
/// Adds more data to the codec to be processed. /// Adds more data to the codec to be processed.
/// </summary> /// </summary>
/// <param name="data">Byte array containing the data to be added to the codec</param> /// <param name="data">Byte array containing the data to be added to the codec</param>
/// <param name="offset">The index of the first byte to add from <c>data</c></param> /// <param name="offset">The index of the first byte to add from <c>data</c></param>
/// <param name="count">The number of bytes to add</param> /// <param name="count">The number of bytes to add</param>
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks> /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
void Add(byte[] data, int offset, int count); void Add(byte[] data, int offset, int count);
/// <summary> /// <summary>
/// Finishes up any pending data that needs to be processed and handled. /// Finishes up any pending data that needs to be processed and handled.
/// </summary> /// </summary>
void Finish(); void Finish();
/// <summary> /// <summary>
/// Gets the checksum of the data that has been added so far /// Gets the checksum of the data that has been added so far
/// </summary> /// </summary>
uint Checksum { get; } uint Checksum { get; }
} }
#endregion #endregion
#region Classes #region Classes
/// <summary> /// <summary>
/// Encapsulates general information about the ZLib library /// Encapsulates general information about the ZLib library
/// </summary> /// </summary>
public class Info public class Info
{ {
#region DLL imports #region DLL imports
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern uint zlibCompileFlags(); private static extern uint zlibCompileFlags();
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern string zlibVersion(); private static extern string zlibVersion();
#endregion #endregion
#region Private stuff #region Private stuff
private uint _flags; private uint _flags;
// helper function that unpacks a bitsize mask // helper function that unpacks a bitsize mask
private static int bitSize(uint bits) private static int bitSize(uint bits)
{ {
switch (bits) switch (bits)
{ {
case 0: return 16; case 0: return 16;
case 1: return 32; case 1: return 32;
case 2: return 64; case 2: return 64;
} }
return -1; return -1;
} }
#endregion #endregion
/// <summary> /// <summary>
/// Constructs an instance of the <c>Info</c> class. /// Constructs an instance of the <c>Info</c> class.
/// </summary> /// </summary>
public Info() public Info()
{ {
_flags = zlibCompileFlags(); _flags = zlibCompileFlags();
} }
/// <summary> /// <summary>
/// True if the library is compiled with debug info /// True if the library is compiled with debug info
/// </summary> /// </summary>
public bool HasDebugInfo { get { return 0 != (_flags & 0x100); } } public bool HasDebugInfo { get { return 0 != (_flags & 0x100); } }
/// <summary> /// <summary>
/// True if the library is compiled with assembly optimizations /// True if the library is compiled with assembly optimizations
/// </summary> /// </summary>
public bool UsesAssemblyCode { get { return 0 != (_flags & 0x200); } } public bool UsesAssemblyCode { get { return 0 != (_flags & 0x200); } }
/// <summary> /// <summary>
/// Gets the size of the unsigned int that was compiled into Zlib /// Gets the size of the unsigned int that was compiled into Zlib
/// </summary> /// </summary>
public int SizeOfUInt { get { return bitSize(_flags & 3); } } public int SizeOfUInt { get { return bitSize(_flags & 3); } }
/// <summary> /// <summary>
/// Gets the size of the unsigned long that was compiled into Zlib /// Gets the size of the unsigned long that was compiled into Zlib
/// </summary> /// </summary>
public int SizeOfULong { get { return bitSize((_flags >> 2) & 3); } } public int SizeOfULong { get { return bitSize((_flags >> 2) & 3); } }
/// <summary> /// <summary>
/// Gets the size of the pointers that were compiled into Zlib /// Gets the size of the pointers that were compiled into Zlib
/// </summary> /// </summary>
public int SizeOfPointer { get { return bitSize((_flags >> 4) & 3); } } public int SizeOfPointer { get { return bitSize((_flags >> 4) & 3); } }
/// <summary> /// <summary>
/// Gets the size of the z_off_t type that was compiled into Zlib /// Gets the size of the z_off_t type that was compiled into Zlib
/// </summary> /// </summary>
public int SizeOfOffset { get { return bitSize((_flags >> 6) & 3); } } public int SizeOfOffset { get { return bitSize((_flags >> 6) & 3); } }
/// <summary> /// <summary>
/// Gets the version of ZLib as a string, e.g. "1.2.1" /// Gets the version of ZLib as a string, e.g. "1.2.1"
/// </summary> /// </summary>
public static string Version { get { return zlibVersion(); } } public static string Version { get { return zlibVersion(); } }
} }
#endregion #endregion
} }

282
contrib/zlib/contrib/dotzlib/DotZLib/DotZLib.csproj
View File

@ -1,141 +1,141 @@
<VisualStudioProject> <VisualStudioProject>
<CSHARP <CSHARP
ProjectType = "Local" ProjectType = "Local"
ProductVersion = "7.10.3077" ProductVersion = "7.10.3077"
SchemaVersion = "2.0" SchemaVersion = "2.0"
ProjectGuid = "{BB1EE0B1-1808-46CB-B786-949D91117FC5}" ProjectGuid = "{BB1EE0B1-1808-46CB-B786-949D91117FC5}"
> >
<Build> <Build>
<Settings <Settings
ApplicationIcon = "" ApplicationIcon = ""
AssemblyKeyContainerName = "" AssemblyKeyContainerName = ""
AssemblyName = "DotZLib" AssemblyName = "DotZLib"
AssemblyOriginatorKeyFile = "" AssemblyOriginatorKeyFile = ""
DefaultClientScript = "JScript" DefaultClientScript = "JScript"
DefaultHTMLPageLayout = "Grid" DefaultHTMLPageLayout = "Grid"
DefaultTargetSchema = "IE50" DefaultTargetSchema = "IE50"
DelaySign = "false" DelaySign = "false"
OutputType = "Library" OutputType = "Library"
PreBuildEvent = "" PreBuildEvent = ""
PostBuildEvent = "" PostBuildEvent = ""
RootNamespace = "DotZLib" RootNamespace = "DotZLib"
RunPostBuildEvent = "OnBuildSuccess" RunPostBuildEvent = "OnBuildSuccess"
StartupObject = "" StartupObject = ""
> >
<Config <Config
Name = "Debug" Name = "Debug"
AllowUnsafeBlocks = "false" AllowUnsafeBlocks = "false"
BaseAddress = "285212672" BaseAddress = "285212672"
CheckForOverflowUnderflow = "false" CheckForOverflowUnderflow = "false"
ConfigurationOverrideFile = "" ConfigurationOverrideFile = ""
DefineConstants = "DEBUG;TRACE" DefineConstants = "DEBUG;TRACE"
DocumentationFile = "docs\DotZLib.xml" DocumentationFile = "docs\DotZLib.xml"
DebugSymbols = "true" DebugSymbols = "true"
FileAlignment = "4096" FileAlignment = "4096"
IncrementalBuild = "false" IncrementalBuild = "false"
NoStdLib = "false" NoStdLib = "false"
NoWarn = "1591" NoWarn = "1591"
Optimize = "false" Optimize = "false"
OutputPath = "bin\Debug\" OutputPath = "bin\Debug\"
RegisterForComInterop = "false" RegisterForComInterop = "false"
RemoveIntegerChecks = "false" RemoveIntegerChecks = "false"
TreatWarningsAsErrors = "false" TreatWarningsAsErrors = "false"
WarningLevel = "4" WarningLevel = "4"
/> />
<Config <Config
Name = "Release" Name = "Release"
AllowUnsafeBlocks = "false" AllowUnsafeBlocks = "false"
BaseAddress = "285212672" BaseAddress = "285212672"
CheckForOverflowUnderflow = "false" CheckForOverflowUnderflow = "false"
ConfigurationOverrideFile = "" ConfigurationOverrideFile = ""
DefineConstants = "TRACE" DefineConstants = "TRACE"
DocumentationFile = "docs\DotZLib.xml" DocumentationFile = "docs\DotZLib.xml"
DebugSymbols = "false" DebugSymbols = "false"
FileAlignment = "4096" FileAlignment = "4096"
IncrementalBuild = "false" IncrementalBuild = "false"
NoStdLib = "false" NoStdLib = "false"
NoWarn = "" NoWarn = ""
Optimize = "true" Optimize = "true"
OutputPath = "bin\Release\" OutputPath = "bin\Release\"
RegisterForComInterop = "false" RegisterForComInterop = "false"
RemoveIntegerChecks = "false" RemoveIntegerChecks = "false"
TreatWarningsAsErrors = "false" TreatWarningsAsErrors = "false"
WarningLevel = "4" WarningLevel = "4"
/> />
</Settings> </Settings>
<References> <References>
<Reference <Reference
Name = "System" Name = "System"
AssemblyName = "System" AssemblyName = "System"
HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.dll" HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.dll"
/> />
<Reference <Reference
Name = "System.Data" Name = "System.Data"
AssemblyName = "System.Data" AssemblyName = "System.Data"
HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.Data.dll" HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
/> />
<Reference <Reference
Name = "System.XML" Name = "System.XML"
AssemblyName = "System.Xml" AssemblyName = "System.Xml"
HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.XML.dll" HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
/> />
<Reference <Reference
Name = "nunit.framework" Name = "nunit.framework"
AssemblyName = "nunit.framework" AssemblyName = "nunit.framework"
HintPath = "E:\apps\NUnit V2.1\\bin\nunit.framework.dll" HintPath = "E:\apps\NUnit V2.1\\bin\nunit.framework.dll"
AssemblyFolderKey = "hklm\dn\nunit.framework" AssemblyFolderKey = "hklm\dn\nunit.framework"
/> />
</References> </References>
</Build> </Build>
<Files> <Files>
<Include> <Include>
<File <File
RelPath = "AssemblyInfo.cs" RelPath = "AssemblyInfo.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "ChecksumImpl.cs" RelPath = "ChecksumImpl.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "CircularBuffer.cs" RelPath = "CircularBuffer.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "CodecBase.cs" RelPath = "CodecBase.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "Deflater.cs" RelPath = "Deflater.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "DotZLib.cs" RelPath = "DotZLib.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "GZipStream.cs" RelPath = "GZipStream.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "Inflater.cs" RelPath = "Inflater.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
<File <File
RelPath = "UnitTests.cs" RelPath = "UnitTests.cs"
SubType = "Code" SubType = "Code"
BuildAction = "Compile" BuildAction = "Compile"
/> />
</Include> </Include>
</Files> </Files>
</CSHARP> </CSHARP>
</VisualStudioProject> </VisualStudioProject>

602
contrib/zlib/contrib/dotzlib/DotZLib/GZipStream.cs
View File

@ -1,301 +1,301 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.IO; using System.IO;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace DotZLib namespace DotZLib
{ {
/// <summary> /// <summary>
/// Implements a compressed <see cref="Stream"/>, in GZip (.gz) format. /// Implements a compressed <see cref="Stream"/>, in GZip (.gz) format.
/// </summary> /// </summary>
public class GZipStream : Stream, IDisposable public class GZipStream : Stream, IDisposable
{ {
#region Dll Imports #region Dll Imports
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
private static extern IntPtr gzopen(string name, string mode); private static extern IntPtr gzopen(string name, string mode);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int gzclose(IntPtr gzFile); private static extern int gzclose(IntPtr gzFile);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int gzwrite(IntPtr gzFile, int data, int length); private static extern int gzwrite(IntPtr gzFile, int data, int length);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int gzread(IntPtr gzFile, int data, int length); private static extern int gzread(IntPtr gzFile, int data, int length);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int gzgetc(IntPtr gzFile); private static extern int gzgetc(IntPtr gzFile);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int gzputc(IntPtr gzFile, int c); private static extern int gzputc(IntPtr gzFile, int c);
#endregion #endregion
#region Private data #region Private data
private IntPtr _gzFile; private IntPtr _gzFile;
private bool _isDisposed = false; private bool _isDisposed = false;
private bool _isWriting; private bool _isWriting;
#endregion #endregion
#region Constructors #region Constructors
/// <summary> /// <summary>
/// Creates a new file as a writeable GZipStream /// Creates a new file as a writeable GZipStream
/// </summary> /// </summary>
/// <param name="fileName">The name of the compressed file to create</param> /// <param name="fileName">The name of the compressed file to create</param>
/// <param name="level">The compression level to use when adding data</param> /// <param name="level">The compression level to use when adding data</param>
/// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception> /// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception>
public GZipStream(string fileName, CompressLevel level) public GZipStream(string fileName, CompressLevel level)
{ {
_isWriting = true; _isWriting = true;
_gzFile = gzopen(fileName, String.Format("wb{0}", (int)level)); _gzFile = gzopen(fileName, String.Format("wb{0}", (int)level));
if (_gzFile == IntPtr.Zero) if (_gzFile == IntPtr.Zero)
throw new ZLibException(-1, "Could not open " + fileName); throw new ZLibException(-1, "Could not open " + fileName);
} }
/// <summary> /// <summary>
/// Opens an existing file as a readable GZipStream /// Opens an existing file as a readable GZipStream
/// </summary> /// </summary>
/// <param name="fileName">The name of the file to open</param> /// <param name="fileName">The name of the file to open</param>
/// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception> /// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception>
public GZipStream(string fileName) public GZipStream(string fileName)
{ {
_isWriting = false; _isWriting = false;
_gzFile = gzopen(fileName, "rb"); _gzFile = gzopen(fileName, "rb");
if (_gzFile == IntPtr.Zero) if (_gzFile == IntPtr.Zero)
throw new ZLibException(-1, "Could not open " + fileName); throw new ZLibException(-1, "Could not open " + fileName);
} }
#endregion #endregion
#region Access properties #region Access properties
/// <summary> /// <summary>
/// Returns true of this stream can be read from, false otherwise /// Returns true of this stream can be read from, false otherwise
/// </summary> /// </summary>
public override bool CanRead public override bool CanRead
{ {
get get
{ {
return !_isWriting; return !_isWriting;
} }
} }
/// <summary> /// <summary>
/// Returns false. /// Returns false.
/// </summary> /// </summary>
public override bool CanSeek public override bool CanSeek
{ {
get get
{ {
return false; return false;
} }
} }
/// <summary> /// <summary>
/// Returns true if this tsream is writeable, false otherwise /// Returns true if this tsream is writeable, false otherwise
/// </summary> /// </summary>
public override bool CanWrite public override bool CanWrite
{ {
get get
{ {
return _isWriting; return _isWriting;
} }
} }
#endregion #endregion
#region Destructor & IDispose stuff #region Destructor & IDispose stuff
/// <summary> /// <summary>
/// Destroys this instance /// Destroys this instance
/// </summary> /// </summary>
~GZipStream() ~GZipStream()
{ {
cleanUp(false); cleanUp(false);
} }
/// <summary> /// <summary>
/// Closes the external file handle /// Closes the external file handle
/// </summary> /// </summary>
public void Dispose() public void Dispose()
{ {
cleanUp(true); cleanUp(true);
} }
// Does the actual closing of the file handle. // Does the actual closing of the file handle.
private void cleanUp(bool isDisposing) private void cleanUp(bool isDisposing)
{ {
if (!_isDisposed) if (!_isDisposed)
{ {
gzclose(_gzFile); gzclose(_gzFile);
_isDisposed = true; _isDisposed = true;
} }
} }
#endregion #endregion
#region Basic reading and writing #region Basic reading and writing
/// <summary> /// <summary>
/// Attempts to read a number of bytes from the stream. /// Attempts to read a number of bytes from the stream.
/// </summary> /// </summary>
/// <param name="buffer">The destination data buffer</param> /// <param name="buffer">The destination data buffer</param>
/// <param name="offset">The index of the first destination byte in <c>buffer</c></param> /// <param name="offset">The index of the first destination byte in <c>buffer</c></param>
/// <param name="count">The number of bytes requested</param> /// <param name="count">The number of bytes requested</param>
/// <returns>The number of bytes read</returns> /// <returns>The number of bytes read</returns>
/// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception> /// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception>
/// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception> /// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception>
/// <exception cref="ArgumentException">If <c>offset</c> + <c>count</c> is &gt; buffer.Length</exception> /// <exception cref="ArgumentException">If <c>offset</c> + <c>count</c> is &gt; buffer.Length</exception>
/// <exception cref="NotSupportedException">If this stream is not readable.</exception> /// <exception cref="NotSupportedException">If this stream is not readable.</exception>
/// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception> /// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
public override int Read(byte[] buffer, int offset, int count) public override int Read(byte[] buffer, int offset, int count)
{ {
if (!CanRead) throw new NotSupportedException(); if (!CanRead) throw new NotSupportedException();
if (buffer == null) throw new ArgumentNullException(); if (buffer == null) throw new ArgumentNullException();
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException(); if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
if ((offset+count) > buffer.Length) throw new ArgumentException(); if ((offset+count) > buffer.Length) throw new ArgumentException();
if (_isDisposed) throw new ObjectDisposedException("GZipStream"); if (_isDisposed) throw new ObjectDisposedException("GZipStream");
GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned); GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned);
int result; int result;
try try
{ {
result = gzread(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count); result = gzread(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count);
if (result < 0) if (result < 0)
throw new IOException(); throw new IOException();
} }
finally finally
{ {
h.Free(); h.Free();
} }
return result; return result;
} }
/// <summary> /// <summary>
/// Attempts to read a single byte from the stream. /// Attempts to read a single byte from the stream.
/// </summary> /// </summary>
/// <returns>The byte that was read, or -1 in case of error or End-Of-File</returns> /// <returns>The byte that was read, or -1 in case of error or End-Of-File</returns>
public override int ReadByte() public override int ReadByte()
{ {
if (!CanRead) throw new NotSupportedException(); if (!CanRead) throw new NotSupportedException();
if (_isDisposed) throw new ObjectDisposedException("GZipStream"); if (_isDisposed) throw new ObjectDisposedException("GZipStream");
return gzgetc(_gzFile); return gzgetc(_gzFile);
} }
/// <summary> /// <summary>
/// Writes a number of bytes to the stream /// Writes a number of bytes to the stream
/// </summary> /// </summary>
/// <param name="buffer"></param> /// <param name="buffer"></param>
/// <param name="offset"></param> /// <param name="offset"></param>
/// <param name="count"></param> /// <param name="count"></param>
/// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception> /// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception>
/// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception> /// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception>
/// <exception cref="ArgumentException">If <c>offset</c> + <c>count</c> is &gt; buffer.Length</exception> /// <exception cref="ArgumentException">If <c>offset</c> + <c>count</c> is &gt; buffer.Length</exception>
/// <exception cref="NotSupportedException">If this stream is not writeable.</exception> /// <exception cref="NotSupportedException">If this stream is not writeable.</exception>
/// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception> /// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
public override void Write(byte[] buffer, int offset, int count) public override void Write(byte[] buffer, int offset, int count)
{ {
if (!CanWrite) throw new NotSupportedException(); if (!CanWrite) throw new NotSupportedException();
if (buffer == null) throw new ArgumentNullException(); if (buffer == null) throw new ArgumentNullException();
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException(); if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
if ((offset+count) > buffer.Length) throw new ArgumentException(); if ((offset+count) > buffer.Length) throw new ArgumentException();
if (_isDisposed) throw new ObjectDisposedException("GZipStream"); if (_isDisposed) throw new ObjectDisposedException("GZipStream");
GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned); GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned);
try try
{ {
int result = gzwrite(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count); int result = gzwrite(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count);
if (result < 0) if (result < 0)
throw new IOException(); throw new IOException();
} }
finally finally
{ {
h.Free(); h.Free();
} }
} }
/// <summary> /// <summary>
/// Writes a single byte to the stream /// Writes a single byte to the stream
/// </summary> /// </summary>
/// <param name="value">The byte to add to the stream.</param> /// <param name="value">The byte to add to the stream.</param>
/// <exception cref="NotSupportedException">If this stream is not writeable.</exception> /// <exception cref="NotSupportedException">If this stream is not writeable.</exception>
/// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception> /// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
public override void WriteByte(byte value) public override void WriteByte(byte value)
{ {
if (!CanWrite) throw new NotSupportedException(); if (!CanWrite) throw new NotSupportedException();
if (_isDisposed) throw new ObjectDisposedException("GZipStream"); if (_isDisposed) throw new ObjectDisposedException("GZipStream");
int result = gzputc(_gzFile, (int)value); int result = gzputc(_gzFile, (int)value);
if (result < 0) if (result < 0)
throw new IOException(); throw new IOException();
} }
#endregion #endregion
#region Position & length stuff #region Position & length stuff
/// <summary> /// <summary>
/// Not supported. /// Not supported.
/// </summary> /// </summary>
/// <param name="value"></param> /// <param name="value"></param>
/// <exception cref="NotSupportedException">Always thrown</exception> /// <exception cref="NotSupportedException">Always thrown</exception>
public override void SetLength(long value) public override void SetLength(long value)
{ {
throw new NotSupportedException(); throw new NotSupportedException();
} }
/// <summary> /// <summary>
/// Not suppported. /// Not suppported.
/// </summary> /// </summary>
/// <param name="offset"></param> /// <param name="offset"></param>
/// <param name="origin"></param> /// <param name="origin"></param>
/// <returns></returns> /// <returns></returns>
/// <exception cref="NotSupportedException">Always thrown</exception> /// <exception cref="NotSupportedException">Always thrown</exception>
public override long Seek(long offset, SeekOrigin origin) public override long Seek(long offset, SeekOrigin origin)
{ {
throw new NotSupportedException(); throw new NotSupportedException();
} }
/// <summary> /// <summary>
/// Flushes the <c>GZipStream</c>. /// Flushes the <c>GZipStream</c>.
/// </summary> /// </summary>
/// <remarks>In this implementation, this method does nothing. This is because excessive /// <remarks>In this implementation, this method does nothing. This is because excessive
/// flushing may degrade the achievable compression rates.</remarks> /// flushing may degrade the achievable compression rates.</remarks>
public override void Flush() public override void Flush()
{ {
// left empty on purpose // left empty on purpose
} }
/// <summary> /// <summary>
/// Gets/sets the current position in the <c>GZipStream</c>. Not suppported. /// Gets/sets the current position in the <c>GZipStream</c>. Not suppported.
/// </summary> /// </summary>
/// <remarks>In this implementation this property is not supported</remarks> /// <remarks>In this implementation this property is not supported</remarks>
/// <exception cref="NotSupportedException">Always thrown</exception> /// <exception cref="NotSupportedException">Always thrown</exception>
public override long Position public override long Position
{ {
get get
{ {
throw new NotSupportedException(); throw new NotSupportedException();
} }
set set
{ {
throw new NotSupportedException(); throw new NotSupportedException();
} }
} }
/// <summary> /// <summary>
/// Gets the size of the stream. Not suppported. /// Gets the size of the stream. Not suppported.
/// </summary> /// </summary>
/// <remarks>In this implementation this property is not supported</remarks> /// <remarks>In this implementation this property is not supported</remarks>
/// <exception cref="NotSupportedException">Always thrown</exception> /// <exception cref="NotSupportedException">Always thrown</exception>
public override long Length public override long Length
{ {
get get
{ {
throw new NotSupportedException(); throw new NotSupportedException();
} }
} }
#endregion #endregion
} }
} }

210
contrib/zlib/contrib/dotzlib/DotZLib/Inflater.cs
View File

@ -1,105 +1,105 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace DotZLib namespace DotZLib
{ {
/// <summary> /// <summary>
/// Implements a data decompressor, using the inflate algorithm in the ZLib dll /// Implements a data decompressor, using the inflate algorithm in the ZLib dll
/// </summary> /// </summary>
public class Inflater : CodecBase public class Inflater : CodecBase
{ {
#region Dll imports #region Dll imports
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
private static extern int inflateInit_(ref ZStream sz, string vs, int size); private static extern int inflateInit_(ref ZStream sz, string vs, int size);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int inflate(ref ZStream sz, int flush); private static extern int inflate(ref ZStream sz, int flush);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int inflateReset(ref ZStream sz); private static extern int inflateReset(ref ZStream sz);
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)] [DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
private static extern int inflateEnd(ref ZStream sz); private static extern int inflateEnd(ref ZStream sz);
#endregion #endregion
/// <summary> /// <summary>
/// Constructs an new instance of the <c>Inflater</c> /// Constructs an new instance of the <c>Inflater</c>
/// </summary> /// </summary>
public Inflater() : base() public Inflater() : base()
{ {
int retval = inflateInit_(ref _ztream, Info.Version, Marshal.SizeOf(_ztream)); int retval = inflateInit_(ref _ztream, Info.Version, Marshal.SizeOf(_ztream));
if (retval != 0) if (retval != 0)
throw new ZLibException(retval, "Could not initialize inflater"); throw new ZLibException(retval, "Could not initialize inflater");
resetOutput(); resetOutput();
} }
/// <summary> /// <summary>
/// Adds more data to the codec to be processed. /// Adds more data to the codec to be processed.
/// </summary> /// </summary>
/// <param name="data">Byte array containing the data to be added to the codec</param> /// <param name="data">Byte array containing the data to be added to the codec</param>
/// <param name="offset">The index of the first byte to add from <c>data</c></param> /// <param name="offset">The index of the first byte to add from <c>data</c></param>
/// <param name="count">The number of bytes to add</param> /// <param name="count">The number of bytes to add</param>
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks> /// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
public override void Add(byte[] data, int offset, int count) public override void Add(byte[] data, int offset, int count)
{ {
if (data == null) throw new ArgumentNullException(); if (data == null) throw new ArgumentNullException();
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException(); if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
if ((offset+count) > data.Length) throw new ArgumentException(); if ((offset+count) > data.Length) throw new ArgumentException();
int total = count; int total = count;
int inputIndex = offset; int inputIndex = offset;
int err = 0; int err = 0;
while (err >= 0 && inputIndex < total) while (err >= 0 && inputIndex < total)
{ {
copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize)); copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize));
err = inflate(ref _ztream, (int)FlushTypes.None); err = inflate(ref _ztream, (int)FlushTypes.None);
if (err == 0) if (err == 0)
while (_ztream.avail_out == 0) while (_ztream.avail_out == 0)
{ {
OnDataAvailable(); OnDataAvailable();
err = inflate(ref _ztream, (int)FlushTypes.None); err = inflate(ref _ztream, (int)FlushTypes.None);
} }
inputIndex += (int)_ztream.total_in; inputIndex += (int)_ztream.total_in;
} }
setChecksum( _ztream.adler ); setChecksum( _ztream.adler );
} }
/// <summary> /// <summary>
/// Finishes up any pending data that needs to be processed and handled. /// Finishes up any pending data that needs to be processed and handled.
/// </summary> /// </summary>
public override void Finish() public override void Finish()
{ {
int err; int err;
do do
{ {
err = inflate(ref _ztream, (int)FlushTypes.Finish); err = inflate(ref _ztream, (int)FlushTypes.Finish);
OnDataAvailable(); OnDataAvailable();
} }
while (err == 0); while (err == 0);
setChecksum( _ztream.adler ); setChecksum( _ztream.adler );
inflateReset(ref _ztream); inflateReset(ref _ztream);
resetOutput(); resetOutput();
} }
/// <summary> /// <summary>
/// Closes the internal zlib inflate stream /// Closes the internal zlib inflate stream
/// </summary> /// </summary>
protected override void CleanUp() { inflateEnd(ref _ztream); } protected override void CleanUp() { inflateEnd(ref _ztream); }
} }
} }

548
contrib/zlib/contrib/dotzlib/DotZLib/UnitTests.cs
View File

@ -1,274 +1,274 @@
// //
// © Copyright Henrik Ravn 2004 // © Copyright Henrik Ravn 2004
// //
// Use, modification and distribution are subject to the Boost Software License, Version 1.0. // Use, modification and distribution are subject to the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// //
using System; using System;
using System.Collections; using System.Collections;
using System.IO; using System.IO;
// uncomment the define below to include unit tests // uncomment the define below to include unit tests
//#define nunit //#define nunit
#if nunit #if nunit
using NUnit.Framework; using NUnit.Framework;
// Unit tests for the DotZLib class library // Unit tests for the DotZLib class library
// ---------------------------------------- // ----------------------------------------
// //
// Use this with NUnit 2 from http://www.nunit.org // Use this with NUnit 2 from http://www.nunit.org
// //
namespace DotZLibTests namespace DotZLibTests
{ {
using DotZLib; using DotZLib;
// helper methods // helper methods
internal class Utils internal class Utils
{ {
public static bool byteArrEqual( byte[] lhs, byte[] rhs ) public static bool byteArrEqual( byte[] lhs, byte[] rhs )
{ {
if (lhs.Length != rhs.Length) if (lhs.Length != rhs.Length)
return false; return false;
for (int i = lhs.Length-1; i >= 0; --i) for (int i = lhs.Length-1; i >= 0; --i)
if (lhs[i] != rhs[i]) if (lhs[i] != rhs[i])
return false; return false;
return true; return true;
} }
} }
[TestFixture] [TestFixture]
public class CircBufferTests public class CircBufferTests
{ {
#region Circular buffer tests #region Circular buffer tests
[Test] [Test]
public void SinglePutGet() public void SinglePutGet()
{ {
CircularBuffer buf = new CircularBuffer(10); CircularBuffer buf = new CircularBuffer(10);
Assert.AreEqual( 0, buf.Size ); Assert.AreEqual( 0, buf.Size );
Assert.AreEqual( -1, buf.Get() ); Assert.AreEqual( -1, buf.Get() );
Assert.IsTrue(buf.Put( 1 )); Assert.IsTrue(buf.Put( 1 ));
Assert.AreEqual( 1, buf.Size ); Assert.AreEqual( 1, buf.Size );
Assert.AreEqual( 1, buf.Get() ); Assert.AreEqual( 1, buf.Get() );
Assert.AreEqual( 0, buf.Size ); Assert.AreEqual( 0, buf.Size );
Assert.AreEqual( -1, buf.Get() ); Assert.AreEqual( -1, buf.Get() );
} }
[Test] [Test]
public void BlockPutGet() public void BlockPutGet()
{ {
CircularBuffer buf = new CircularBuffer(10); CircularBuffer buf = new CircularBuffer(10);
byte[] arr = {1,2,3,4,5,6,7,8,9,10}; byte[] arr = {1,2,3,4,5,6,7,8,9,10};
Assert.AreEqual( 10, buf.Put(arr,0,10) ); Assert.AreEqual( 10, buf.Put(arr,0,10) );
Assert.AreEqual( 10, buf.Size ); Assert.AreEqual( 10, buf.Size );
Assert.IsFalse( buf.Put(11) ); Assert.IsFalse( buf.Put(11) );
Assert.AreEqual( 1, buf.Get() ); Assert.AreEqual( 1, buf.Get() );
Assert.IsTrue( buf.Put(11) ); Assert.IsTrue( buf.Put(11) );
byte[] arr2 = (byte[])arr.Clone(); byte[] arr2 = (byte[])arr.Clone();
Assert.AreEqual( 9, buf.Get(arr2,1,9) ); Assert.AreEqual( 9, buf.Get(arr2,1,9) );
Assert.IsTrue( Utils.byteArrEqual(arr,arr2) ); Assert.IsTrue( Utils.byteArrEqual(arr,arr2) );
} }
#endregion #endregion
} }
[TestFixture] [TestFixture]
public class ChecksumTests public class ChecksumTests
{ {
#region CRC32 Tests #region CRC32 Tests
[Test] [Test]
public void CRC32_Null() public void CRC32_Null()
{ {
CRC32Checksum crc32 = new CRC32Checksum(); CRC32Checksum crc32 = new CRC32Checksum();
Assert.AreEqual( 0, crc32.Value ); Assert.AreEqual( 0, crc32.Value );
crc32 = new CRC32Checksum(1); crc32 = new CRC32Checksum(1);
Assert.AreEqual( 1, crc32.Value ); Assert.AreEqual( 1, crc32.Value );
crc32 = new CRC32Checksum(556); crc32 = new CRC32Checksum(556);
Assert.AreEqual( 556, crc32.Value ); Assert.AreEqual( 556, crc32.Value );
} }
[Test] [Test]
public void CRC32_Data() public void CRC32_Data()
{ {
CRC32Checksum crc32 = new CRC32Checksum(); CRC32Checksum crc32 = new CRC32Checksum();
byte[] data = { 1,2,3,4,5,6,7 }; byte[] data = { 1,2,3,4,5,6,7 };
crc32.Update(data); crc32.Update(data);
Assert.AreEqual( 0x70e46888, crc32.Value ); Assert.AreEqual( 0x70e46888, crc32.Value );
crc32 = new CRC32Checksum(); crc32 = new CRC32Checksum();
crc32.Update("penguin"); crc32.Update("penguin");
Assert.AreEqual( 0x0e5c1a120, crc32.Value ); Assert.AreEqual( 0x0e5c1a120, crc32.Value );
crc32 = new CRC32Checksum(1); crc32 = new CRC32Checksum(1);
crc32.Update("penguin"); crc32.Update("penguin");
Assert.AreEqual(0x43b6aa94, crc32.Value); Assert.AreEqual(0x43b6aa94, crc32.Value);
} }
#endregion #endregion
#region Adler tests #region Adler tests
[Test] [Test]
public void Adler_Null() public void Adler_Null()
{ {
AdlerChecksum adler = new AdlerChecksum(); AdlerChecksum adler = new AdlerChecksum();
Assert.AreEqual(0, adler.Value); Assert.AreEqual(0, adler.Value);
adler = new AdlerChecksum(1); adler = new AdlerChecksum(1);
Assert.AreEqual( 1, adler.Value ); Assert.AreEqual( 1, adler.Value );
adler = new AdlerChecksum(556); adler = new AdlerChecksum(556);
Assert.AreEqual( 556, adler.Value ); Assert.AreEqual( 556, adler.Value );
} }
[Test] [Test]
public void Adler_Data() public void Adler_Data()
{ {
AdlerChecksum adler = new AdlerChecksum(1); AdlerChecksum adler = new AdlerChecksum(1);
byte[] data = { 1,2,3,4,5,6,7 }; byte[] data = { 1,2,3,4,5,6,7 };
adler.Update(data); adler.Update(data);
Assert.AreEqual( 0x5b001d, adler.Value ); Assert.AreEqual( 0x5b001d, adler.Value );
adler = new AdlerChecksum(); adler = new AdlerChecksum();
adler.Update("penguin"); adler.Update("penguin");
Assert.AreEqual(0x0bcf02f6, adler.Value ); Assert.AreEqual(0x0bcf02f6, adler.Value );
adler = new AdlerChecksum(1); adler = new AdlerChecksum(1);
adler.Update("penguin"); adler.Update("penguin");
Assert.AreEqual(0x0bd602f7, adler.Value); Assert.AreEqual(0x0bd602f7, adler.Value);
} }
#endregion #endregion
} }
[TestFixture] [TestFixture]
public class InfoTests public class InfoTests
{ {
#region Info tests #region Info tests
[Test] [Test]
public void Info_Version() public void Info_Version()
{ {
Info info = new Info(); Info info = new Info();
Assert.AreEqual("1.2.11", Info.Version); Assert.AreEqual("1.2.13", Info.Version);
Assert.AreEqual(32, info.SizeOfUInt); Assert.AreEqual(32, info.SizeOfUInt);
Assert.AreEqual(32, info.SizeOfULong); Assert.AreEqual(32, info.SizeOfULong);
Assert.AreEqual(32, info.SizeOfPointer); Assert.AreEqual(32, info.SizeOfPointer);
Assert.AreEqual(32, info.SizeOfOffset); Assert.AreEqual(32, info.SizeOfOffset);
} }
#endregion #endregion
} }
[TestFixture] [TestFixture]
public class DeflateInflateTests public class DeflateInflateTests
{ {
#region Deflate tests #region Deflate tests
[Test] [Test]
public void Deflate_Init() public void Deflate_Init()
{ {
using (Deflater def = new Deflater(CompressLevel.Default)) using (Deflater def = new Deflater(CompressLevel.Default))
{ {
} }
} }
private ArrayList compressedData = new ArrayList(); private ArrayList compressedData = new ArrayList();
private uint adler1; private uint adler1;
private ArrayList uncompressedData = new ArrayList(); private ArrayList uncompressedData = new ArrayList();
private uint adler2; private uint adler2;
public void CDataAvail(byte[] data, int startIndex, int count) public void CDataAvail(byte[] data, int startIndex, int count)
{ {
for (int i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
compressedData.Add(data[i+startIndex]); compressedData.Add(data[i+startIndex]);
} }
[Test] [Test]
public void Deflate_Compress() public void Deflate_Compress()
{ {
compressedData.Clear(); compressedData.Clear();
byte[] testData = new byte[35000]; byte[] testData = new byte[35000];
for (int i = 0; i < testData.Length; ++i) for (int i = 0; i < testData.Length; ++i)
testData[i] = 5; testData[i] = 5;
using (Deflater def = new Deflater((CompressLevel)5)) using (Deflater def = new Deflater((CompressLevel)5))
{ {
def.DataAvailable += new DataAvailableHandler(CDataAvail); def.DataAvailable += new DataAvailableHandler(CDataAvail);
def.Add(testData); def.Add(testData);
def.Finish(); def.Finish();
adler1 = def.Checksum; adler1 = def.Checksum;
} }
} }
#endregion #endregion
#region Inflate tests #region Inflate tests
[Test] [Test]
public void Inflate_Init() public void Inflate_Init()
{ {
using (Inflater inf = new Inflater()) using (Inflater inf = new Inflater())
{ {
} }
} }
private void DDataAvail(byte[] data, int startIndex, int count) private void DDataAvail(byte[] data, int startIndex, int count)
{ {
for (int i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
uncompressedData.Add(data[i+startIndex]); uncompressedData.Add(data[i+startIndex]);
} }
[Test] [Test]
public void Inflate_Expand() public void Inflate_Expand()
{ {
uncompressedData.Clear(); uncompressedData.Clear();
using (Inflater inf = new Inflater()) using (Inflater inf = new Inflater())
{ {
inf.DataAvailable += new DataAvailableHandler(DDataAvail); inf.DataAvailable += new DataAvailableHandler(DDataAvail);
inf.Add((byte[])compressedData.ToArray(typeof(byte))); inf.Add((byte[])compressedData.ToArray(typeof(byte)));
inf.Finish(); inf.Finish();
adler2 = inf.Checksum; adler2 = inf.Checksum;
} }
Assert.AreEqual( adler1, adler2 ); Assert.AreEqual( adler1, adler2 );
} }
#endregion #endregion
} }
[TestFixture] [TestFixture]
public class GZipStreamTests public class GZipStreamTests
{ {
#region GZipStream test #region GZipStream test
[Test] [Test]
public void GZipStream_WriteRead() public void GZipStream_WriteRead()
{ {
using (GZipStream gzOut = new GZipStream("gzstream.gz", CompressLevel.Best)) using (GZipStream gzOut = new GZipStream("gzstream.gz", CompressLevel.Best))
{ {
BinaryWriter writer = new BinaryWriter(gzOut); BinaryWriter writer = new BinaryWriter(gzOut);
writer.Write("hi there"); writer.Write("hi there");
writer.Write(Math.PI); writer.Write(Math.PI);
writer.Write(42); writer.Write(42);
} }
using (GZipStream gzIn = new GZipStream("gzstream.gz")) using (GZipStream gzIn = new GZipStream("gzstream.gz"))
{ {
BinaryReader reader = new BinaryReader(gzIn); BinaryReader reader = new BinaryReader(gzIn);
string s = reader.ReadString(); string s = reader.ReadString();
Assert.AreEqual("hi there",s); Assert.AreEqual("hi there",s);
double d = reader.ReadDouble(); double d = reader.ReadDouble();
Assert.AreEqual(Math.PI, d); Assert.AreEqual(Math.PI, d);
int i = reader.ReadInt32(); int i = reader.ReadInt32();
Assert.AreEqual(42,i); Assert.AreEqual(42,i);
} }
} }
#endregion #endregion
} }
} }
#endif #endif

2
contrib/zlib/contrib/dotzlib/LICENSE_1_0.txt
View File

@ -20,4 +20,4 @@ FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.

1148
contrib/zlib/contrib/gcc_gvmat64/gvmat64.S
View File

File diff suppressed because it is too large Load Diff

6
contrib/zlib/contrib/infback9/inftree9.c
View File

@ -1,5 +1,5 @@
/* inftree9.c -- generate Huffman trees for efficient decoding /* inftree9.c -- generate Huffman trees for efficient decoding
* Copyright (C) 1995-2017 Mark Adler * Copyright (C) 1995-2022 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -9,7 +9,7 @@
#define MAXBITS 15 #define MAXBITS 15
const char inflate9_copyright[] = const char inflate9_copyright[] =
" inflate9 1.2.11 Copyright 1995-2017 Mark Adler "; " inflate9 1.2.13 Copyright 1995-2022 Mark Adler ";
/* /*
If you use the zlib library in a product, an acknowledgment is welcome 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 in the documentation of your product. If for some reason you cannot
@ -64,7 +64,7 @@ unsigned short FAR *work;
static const unsigned short lext[31] = { /* Length codes 257..285 extra */ static const unsigned short lext[31] = { /* Length codes 257..285 extra */
128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129, 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132, 130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
133, 133, 133, 133, 144, 77, 202}; 133, 133, 133, 133, 144, 194, 65};
static const unsigned short dbase[32] = { /* Distance codes 0..31 base */ static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,

2
contrib/zlib/contrib/infback9/inftree9.h
View File

@ -38,7 +38,7 @@ typedef struct {
/* Maximum size of the dynamic table. The maximum number of code structures is /* Maximum size of the dynamic table. The maximum number of code structures is
1446, which is the sum of 852 for literal/length codes and 594 for distance 1446, which is the sum of 852 for literal/length codes and 594 for distance
codes. These values were found by exhaustive searches using the program codes. These values were found by exhaustive searches using the program
examples/enough.c found in the zlib distribtution. The arguments to that examples/enough.c found in the zlib distribution. The arguments to that
program are the number of symbols, the initial root table size, and the program are the number of symbols, the initial root table size, and the
maximum bit length of a code. "enough 286 9 15" for literal/length codes maximum bit length of a code. "enough 286 9 15" for literal/length codes
returns returns 852, and "enough 32 6 15" for distance codes returns 594. returns returns 852, and "enough 32 6 15" for distance codes returns 594.

2
contrib/zlib/contrib/minizip/configure.ac
View File

@ -1,7 +1,7 @@
# -*- Autoconf -*- # -*- Autoconf -*-
# Process this file with autoconf to produce a configure script. # Process this file with autoconf to produce a configure script.
AC_INIT([minizip], [1.2.11], [bugzilla.redhat.com]) AC_INIT([minizip], [1.2.13], [bugzilla.redhat.com])
AC_CONFIG_SRCDIR([minizip.c]) AC_CONFIG_SRCDIR([minizip.c])
AM_INIT_AUTOMAKE([foreign]) AM_INIT_AUTOMAKE([foreign])
LT_INIT LT_INIT

19
contrib/zlib/contrib/minizip/crypt.h
View File

@ -38,6 +38,7 @@ static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)
* unpredictable manner on 16-bit systems; not a problem * unpredictable manner on 16-bit systems; not a problem
* with any known compiler so far, though */ * with any known compiler so far, though */
(void)pcrc_32_tab;
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
} }
@ -77,24 +78,24 @@ static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcr
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
#define zencode(pkeys,pcrc_32_tab,c,t) \ #define zencode(pkeys,pcrc_32_tab,c,t) \
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), (Byte)t^(c))
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED #ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
#define RAND_HEAD_LEN 12 #define RAND_HEAD_LEN 12
/* "last resort" source for second part of crypt seed pattern */ /* "last resort" source for second part of crypt seed pattern */
# ifndef ZCR_SEED2 # ifndef ZCR_SEED2
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ # define ZCR_SEED2 3141592654UL /* use PI as default pattern */
# endif # endif
static int crypthead(const char* passwd, /* password string */ static unsigned crypthead(const char* passwd, /* password string */
unsigned char* buf, /* where to write header */ unsigned char* buf, /* where to write header */
int bufSize, int bufSize,
unsigned long* pkeys, unsigned long* pkeys,
const z_crc_t* pcrc_32_tab, const z_crc_t* pcrc_32_tab,
unsigned long crcForCrypting) unsigned long crcForCrypting)
{ {
int n; /* index in random header */ unsigned n; /* index in random header */
int t; /* temporary */ int t; /* temporary */
int c; /* random byte */ int c; /* random byte */
unsigned char header[RAND_HEAD_LEN-2]; /* random header */ unsigned char header[RAND_HEAD_LEN-2]; /* random header */

18
contrib/zlib/contrib/minizip/ioapi.c
View File

@ -58,7 +58,7 @@ ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream
return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream); return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
else else
{ {
uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream); uLong tell_uLong = (uLong)(*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
if ((tell_uLong) == MAXU32) if ((tell_uLong) == MAXU32)
return (ZPOS64_T)-1; return (ZPOS64_T)-1;
else else
@ -96,6 +96,7 @@ static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, in
{ {
FILE* file = NULL; FILE* file = NULL;
const char* mode_fopen = NULL; const char* mode_fopen = NULL;
(void)opaque;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
mode_fopen = "rb"; mode_fopen = "rb";
else else
@ -114,6 +115,7 @@ static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename,
{ {
FILE* file = NULL; FILE* file = NULL;
const char* mode_fopen = NULL; const char* mode_fopen = NULL;
(void)opaque;
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
mode_fopen = "rb"; mode_fopen = "rb";
else else
@ -132,6 +134,7 @@ static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename,
static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size) static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
{ {
uLong ret; uLong ret;
(void)opaque;
ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream); ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
return ret; return ret;
} }
@ -139,6 +142,7 @@ static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf,
static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size) static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
{ {
uLong ret; uLong ret;
(void)opaque;
ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream); ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
return ret; return ret;
} }
@ -146,6 +150,7 @@ static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const voi
static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream) static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
{ {
long ret; long ret;
(void)opaque;
ret = ftell((FILE *)stream); ret = ftell((FILE *)stream);
return ret; return ret;
} }
@ -154,7 +159,8 @@ static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream) static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
{ {
ZPOS64_T ret; ZPOS64_T ret;
ret = FTELLO_FUNC((FILE *)stream); (void)opaque;
ret = (ZPOS64_T)FTELLO_FUNC((FILE *)stream);
return ret; return ret;
} }
@ -162,6 +168,7 @@ static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offs
{ {
int fseek_origin=0; int fseek_origin=0;
long ret; long ret;
(void)opaque;
switch (origin) switch (origin)
{ {
case ZLIB_FILEFUNC_SEEK_CUR : case ZLIB_FILEFUNC_SEEK_CUR :
@ -176,7 +183,7 @@ static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offs
default: return -1; default: return -1;
} }
ret = 0; ret = 0;
if (fseek((FILE *)stream, offset, fseek_origin) != 0) if (fseek((FILE *)stream, (long)offset, fseek_origin) != 0)
ret = -1; ret = -1;
return ret; return ret;
} }
@ -185,6 +192,7 @@ static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T
{ {
int fseek_origin=0; int fseek_origin=0;
long ret; long ret;
(void)opaque;
switch (origin) switch (origin)
{ {
case ZLIB_FILEFUNC_SEEK_CUR : case ZLIB_FILEFUNC_SEEK_CUR :
@ -200,7 +208,7 @@ static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T
} }
ret = 0; ret = 0;
if(FSEEKO_FUNC((FILE *)stream, offset, fseek_origin) != 0) if(FSEEKO_FUNC((FILE *)stream, (z_off_t)offset, fseek_origin) != 0)
ret = -1; ret = -1;
return ret; return ret;
@ -210,6 +218,7 @@ static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T
static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream) static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
{ {
int ret; int ret;
(void)opaque;
ret = fclose((FILE *)stream); ret = fclose((FILE *)stream);
return ret; return ret;
} }
@ -217,6 +226,7 @@ static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream) static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
{ {
int ret; int ret;
(void)opaque;
ret = ferror((FILE *)stream); ret = ferror((FILE *)stream);
return ret; return ret;
} }

10
contrib/zlib/contrib/minizip/ioapi.h
View File

@ -50,7 +50,7 @@
#define ftello64 ftell #define ftello64 ftell
#define fseeko64 fseek #define fseeko64 fseek
#else #else
#ifdef __FreeBSD__ #if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
#define fopen64 fopen #define fopen64 fopen
#define ftello64 ftello #define ftello64 ftello
#define fseeko64 fseeko #define fseeko64 fseeko
@ -91,8 +91,7 @@ typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;
typedef uint64_t ZPOS64_T; typedef uint64_t ZPOS64_T;
#else #else
/* Maximum unsigned 32-bit value used as placeholder for zip64 */
#define MAXU32 0xffffffff
#if defined(_MSC_VER) || defined(__BORLANDC__) #if defined(_MSC_VER) || defined(__BORLANDC__)
typedef unsigned __int64 ZPOS64_T; typedef unsigned __int64 ZPOS64_T;
@ -102,7 +101,10 @@ typedef unsigned long long int ZPOS64_T;
#endif #endif
#endif #endif
/* Maximum unsigned 32-bit value used as placeholder for zip64 */
#ifndef MAXU32
#define MAXU32 (0xffffffff)
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

5
contrib/zlib/contrib/minizip/iowin32.c
View File

@ -28,6 +28,11 @@
// see Include/shared/winapifamily.h in the Windows Kit // see Include/shared/winapifamily.h in the Windows Kit
#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API))) #if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
#if !defined(WINAPI_FAMILY_ONE_PARTITION)
#define WINAPI_FAMILY_ONE_PARTITION(PartitionSet, Partition) ((WINAPI_FAMILY & PartitionSet) == Partition)
#endif
#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP) #if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
#define IOWIN32_USING_WINRT_API 1 #define IOWIN32_USING_WINRT_API 1
#endif #endif

37
contrib/zlib/contrib/minizip/miniunz.c
View File

@ -45,6 +45,7 @@
#include <time.h> #include <time.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/stat.h>
#ifdef _WIN32 #ifdef _WIN32
# include <direct.h> # include <direct.h>
@ -80,7 +81,7 @@
filename : the filename of the file where date/time must be modified filename : the filename of the file where date/time must be modified
dosdate : the new date at the MSDos format (4 bytes) dosdate : the new date at the MSDos format (4 bytes)
tmu_date : the SAME new date at the tm_unz format */ tmu_date : the SAME new date at the tm_unz format */
void change_file_date(filename,dosdate,tmu_date) static void change_file_date(filename,dosdate,tmu_date)
const char *filename; const char *filename;
uLong dosdate; uLong dosdate;
tm_unz tmu_date; tm_unz tmu_date;
@ -97,7 +98,8 @@ void change_file_date(filename,dosdate,tmu_date)
SetFileTime(hFile,&ftm,&ftLastAcc,&ftm); SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
CloseHandle(hFile); CloseHandle(hFile);
#else #else
#ifdef unix || __APPLE__ #if defined(unix) || defined(__APPLE__)
(void)dosdate;
struct utimbuf ut; struct utimbuf ut;
struct tm newdate; struct tm newdate;
newdate.tm_sec = tmu_date.tm_sec; newdate.tm_sec = tmu_date.tm_sec;
@ -121,7 +123,7 @@ void change_file_date(filename,dosdate,tmu_date)
/* mymkdir and change_file_date are not 100 % portable /* mymkdir and change_file_date are not 100 % portable
As I don't know well Unix, I wait feedback for the unix portion */ As I don't know well Unix, I wait feedback for the unix portion */
int mymkdir(dirname) static int mymkdir(dirname)
const char* dirname; const char* dirname;
{ {
int ret=0; int ret=0;
@ -135,14 +137,14 @@ int mymkdir(dirname)
return ret; return ret;
} }
int makedir (newdir) static int makedir (newdir)
char *newdir; const char *newdir;
{ {
char *buffer ; char *buffer ;
char *p; char *p;
int len = (int)strlen(newdir); size_t len = strlen(newdir);
if (len <= 0) if (len == 0)
return 0; return 0;
buffer = (char*)malloc(len+1); buffer = (char*)malloc(len+1);
@ -185,13 +187,13 @@ int makedir (newdir)
return 1; return 1;
} }
void do_banner() static void do_banner()
{ {
printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n"); printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n");
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
} }
void do_help() static void do_help()
{ {
printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \ printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \
" -e Extract without pathname (junk paths)\n" \ " -e Extract without pathname (junk paths)\n" \
@ -203,7 +205,7 @@ void do_help()
" -p extract crypted file using password\n\n"); " -p extract crypted file using password\n\n");
} }
void Display64BitsSize(ZPOS64_T n, int size_char) static void Display64BitsSize(ZPOS64_T n, int size_char)
{ {
/* to avoid compatibility problem , we do here the conversion */ /* to avoid compatibility problem , we do here the conversion */
char number[21]; char number[21];
@ -231,7 +233,7 @@ void Display64BitsSize(ZPOS64_T n, int size_char)
printf("%s",&number[pos_string]); printf("%s",&number[pos_string]);
} }
int do_list(uf) static int do_list(uf)
unzFile uf; unzFile uf;
{ {
uLong i; uLong i;
@ -309,7 +311,7 @@ int do_list(uf)
} }
int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password) static int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
unzFile uf; unzFile uf;
const int* popt_extract_without_path; const int* popt_extract_without_path;
int* popt_overwrite; int* popt_overwrite;
@ -324,7 +326,6 @@ int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
uInt size_buf; uInt size_buf;
unz_file_info64 file_info; unz_file_info64 file_info;
uLong ratio=0;
err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
if (err!=UNZ_OK) if (err!=UNZ_OK)
@ -439,7 +440,7 @@ int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
break; break;
} }
if (err>0) if (err>0)
if (fwrite(buf,err,1,fout)!=1) if (fwrite(buf,(unsigned)err,1,fout)!=1)
{ {
printf("error in writing extracted file\n"); printf("error in writing extracted file\n");
err=UNZ_ERRNO; err=UNZ_ERRNO;
@ -472,7 +473,7 @@ int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
} }
int do_extract(uf,opt_extract_without_path,opt_overwrite,password) static int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
unzFile uf; unzFile uf;
int opt_extract_without_path; int opt_extract_without_path;
int opt_overwrite; int opt_overwrite;
@ -481,7 +482,6 @@ int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
uLong i; uLong i;
unz_global_info64 gi; unz_global_info64 gi;
int err; int err;
FILE* fout=NULL;
err = unzGetGlobalInfo64(uf,&gi); err = unzGetGlobalInfo64(uf,&gi);
if (err!=UNZ_OK) if (err!=UNZ_OK)
@ -508,14 +508,13 @@ int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
return 0; return 0;
} }
int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password) static int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password)
unzFile uf; unzFile uf;
const char* filename; const char* filename;
int opt_extract_without_path; int opt_extract_without_path;
int opt_overwrite; int opt_overwrite;
const char* password; const char* password;
{ {
int err = UNZ_OK;
if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK) if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
{ {
printf("file %s not found in the zipfile\n",filename); printf("file %s not found in the zipfile\n",filename);
@ -565,7 +564,7 @@ int main(argc,argv)
while ((*p)!='\0') while ((*p)!='\0')
{ {
char c=*(p++);; char c=*(p++);
if ((c=='l') || (c=='L')) if ((c=='l') || (c=='L'))
opt_do_list = 1; opt_do_list = 1;
if ((c=='v') || (c=='V')) if ((c=='v') || (c=='V'))

47
contrib/zlib/contrib/minizip/minizip.c
View File

@ -71,8 +71,8 @@
#define MAXFILENAME (256) #define MAXFILENAME (256)
#ifdef _WIN32 #ifdef _WIN32
uLong filetime(f, tmzip, dt) static int filetime(f, tmzip, dt)
char *f; /* name of file to get info on */ const char *f; /* name of file to get info on */
tm_zip *tmzip; /* return value: access, modific. and creation times */ tm_zip *tmzip; /* return value: access, modific. and creation times */
uLong *dt; /* dostime */ uLong *dt; /* dostime */
{ {
@ -94,12 +94,13 @@ uLong filetime(f, tmzip, dt)
return ret; return ret;
} }
#else #else
#ifdef unix || __APPLE__ #if defined(unix) || defined(__APPLE__)
uLong filetime(f, tmzip, dt) static int filetime(f, tmzip, dt)
char *f; /* name of file to get info on */ const char *f; /* name of file to get info on */
tm_zip *tmzip; /* return value: access, modific. and creation times */ tm_zip *tmzip; /* return value: access, modific. and creation times */
uLong *dt; /* dostime */ uLong *dt; /* dostime */
{ {
(void)dt;
int ret=0; int ret=0;
struct stat s; /* results of stat() */ struct stat s; /* results of stat() */
struct tm* filedate; struct tm* filedate;
@ -108,7 +109,7 @@ uLong filetime(f, tmzip, dt)
if (strcmp(f,"-")!=0) if (strcmp(f,"-")!=0)
{ {
char name[MAXFILENAME+1]; char name[MAXFILENAME+1];
int len = strlen(f); size_t len = strlen(f);
if (len > MAXFILENAME) if (len > MAXFILENAME)
len = MAXFILENAME; len = MAXFILENAME;
@ -138,7 +139,7 @@ uLong filetime(f, tmzip, dt)
} }
#else #else
uLong filetime(f, tmzip, dt) uLong filetime(f, tmzip, dt)
char *f; /* name of file to get info on */ const char *f; /* name of file to get info on */
tm_zip *tmzip; /* return value: access, modific. and creation times */ tm_zip *tmzip; /* return value: access, modific. and creation times */
uLong *dt; /* dostime */ uLong *dt; /* dostime */
{ {
@ -150,7 +151,7 @@ uLong filetime(f, tmzip, dt)
int check_exist_file(filename) static int check_exist_file(filename)
const char* filename; const char* filename;
{ {
FILE* ftestexist; FILE* ftestexist;
@ -163,13 +164,13 @@ int check_exist_file(filename)
return ret; return ret;
} }
void do_banner() static void do_banner()
{ {
printf("MiniZip 1.1, demo of zLib + MiniZip64 package, written by Gilles Vollant\n"); printf("MiniZip 1.1, demo of zLib + MiniZip64 package, written by Gilles Vollant\n");
printf("more info on MiniZip at http://www.winimage.com/zLibDll/minizip.html\n\n"); printf("more info on MiniZip at http://www.winimage.com/zLibDll/minizip.html\n\n");
} }
void do_help() static void do_help()
{ {
printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] [-j] file.zip [files_to_add]\n\n" \ printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] [-j] file.zip [files_to_add]\n\n" \
" -o Overwrite existing file.zip\n" \ " -o Overwrite existing file.zip\n" \
@ -182,14 +183,14 @@ void do_help()
/* calculate the CRC32 of a file, /* calculate the CRC32 of a file,
because to encrypt a file, we need known the CRC32 of the file before */ because to encrypt a file, we need known the CRC32 of the file before */
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) static int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
{ {
unsigned long calculate_crc=0; unsigned long calculate_crc=0;
int err=ZIP_OK; int err=ZIP_OK;
FILE * fin = FOPEN_FUNC(filenameinzip,"rb"); FILE * fin = FOPEN_FUNC(filenameinzip,"rb");
unsigned long size_read = 0; unsigned long size_read = 0;
unsigned long total_read = 0; /* unsigned long total_read = 0; */
if (fin==NULL) if (fin==NULL)
{ {
err = ZIP_ERRNO; err = ZIP_ERRNO;
@ -199,7 +200,7 @@ int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigne
do do
{ {
err = ZIP_OK; err = ZIP_OK;
size_read = (int)fread(buf,1,size_buf,fin); size_read = fread(buf,1,size_buf,fin);
if (size_read < size_buf) if (size_read < size_buf)
if (feof(fin)==0) if (feof(fin)==0)
{ {
@ -208,8 +209,8 @@ int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigne
} }
if (size_read>0) if (size_read>0)
calculate_crc = crc32(calculate_crc,buf,size_read); calculate_crc = crc32_z(calculate_crc,buf,size_read);
total_read += size_read; /* total_read += size_read; */
} while ((err == ZIP_OK) && (size_read>0)); } while ((err == ZIP_OK) && (size_read>0));
@ -221,7 +222,7 @@ int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigne
return err; return err;
} }
int isLargeFile(const char* filename) static int isLargeFile(const char* filename)
{ {
int largeFile = 0; int largeFile = 0;
ZPOS64_T pos = 0; ZPOS64_T pos = 0;
@ -229,8 +230,8 @@ int isLargeFile(const char* filename)
if(pFile != NULL) if(pFile != NULL)
{ {
int n = FSEEKO_FUNC(pFile, 0, SEEK_END); FSEEKO_FUNC(pFile, 0, SEEK_END);
pos = FTELLO_FUNC(pFile); pos = (ZPOS64_T)FTELLO_FUNC(pFile);
printf("File : %s is %lld bytes\n", filename, pos); printf("File : %s is %lld bytes\n", filename, pos);
@ -255,7 +256,7 @@ int main(argc,argv)
char filename_try[MAXFILENAME+16]; char filename_try[MAXFILENAME+16];
int zipok; int zipok;
int err=0; int err=0;
int size_buf=0; size_t size_buf=0;
void* buf=NULL; void* buf=NULL;
const char* password=NULL; const char* password=NULL;
@ -276,7 +277,7 @@ int main(argc,argv)
while ((*p)!='\0') while ((*p)!='\0')
{ {
char c=*(p++);; char c=*(p++);
if ((c=='o') || (c=='O')) if ((c=='o') || (c=='O'))
opt_overwrite = 1; opt_overwrite = 1;
if ((c=='a') || (c=='A')) if ((c=='a') || (c=='A'))
@ -396,7 +397,7 @@ int main(argc,argv)
(strlen(argv[i]) == 2))) (strlen(argv[i]) == 2)))
{ {
FILE * fin; FILE * fin;
int size_read; size_t size_read;
const char* filenameinzip = argv[i]; const char* filenameinzip = argv[i];
const char *savefilenameinzip; const char *savefilenameinzip;
zip_fileinfo zi; zip_fileinfo zi;
@ -472,7 +473,7 @@ int main(argc,argv)
do do
{ {
err = ZIP_OK; err = ZIP_OK;
size_read = (int)fread(buf,1,size_buf,fin); size_read = fread(buf,1,size_buf,fin);
if (size_read < size_buf) if (size_read < size_buf)
if (feof(fin)==0) if (feof(fin)==0)
{ {
@ -482,7 +483,7 @@ int main(argc,argv)
if (size_read>0) if (size_read>0)
{ {
err = zipWriteInFileInZip (zf,buf,size_read); err = zipWriteInFileInZip (zf,buf,(unsigned)size_read);
if (err<0) if (err<0)
{ {
printf("error in writing %s in the zipfile\n", printf("error in writing %s in the zipfile\n",

35
contrib/zlib/contrib/minizip/unzip.c
View File

@ -112,7 +112,7 @@
# define ALLOC(size) (malloc(size)) # define ALLOC(size) (malloc(size))
#endif #endif
#ifndef TRYFREE #ifndef TRYFREE
# define TRYFREE(p) {if (p) free(p);} # define TRYFREE(p) { free(p);}
#endif #endif
#define SIZECENTRALDIRITEM (0x2e) #define SIZECENTRALDIRITEM (0x2e)
@ -455,7 +455,7 @@ local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_f
if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
{ {
uPosFound = uReadPos+i; uPosFound = uReadPos+(unsigned)i;
break; break;
} }
@ -523,7 +523,7 @@ local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07)) ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
{ {
uPosFound = uReadPos+i; uPosFound = uReadPos+(unsigned)i;
break; break;
} }
@ -853,13 +853,13 @@ local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
{ {
ZPOS64_T uDate; ZPOS64_T uDate;
uDate = (ZPOS64_T)(ulDosDate>>16); uDate = (ZPOS64_T)(ulDosDate>>16);
ptm->tm_mday = (uInt)(uDate&0x1f) ; ptm->tm_mday = (int)(uDate&0x1f) ;
ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ; ptm->tm_mon = (int)((((uDate)&0x1E0)/0x20)-1) ;
ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ; ptm->tm_year = (int)(((uDate&0x0FE00)/0x0200)+1980) ;
ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); ptm->tm_hour = (int) ((ulDosDate &0xF800)/0x800);
ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ; ptm->tm_min = (int) ((ulDosDate&0x7E0)/0x20) ;
ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ; ptm->tm_sec = (int) (2*(ulDosDate&0x1f)) ;
} }
/* /*
@ -993,7 +993,7 @@ local int unz64local_GetCurrentFileInfoInternal (unzFile file,
if (lSeek!=0) if (lSeek!=0)
{ {
if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) if (ZSEEK64(s->z_filefunc, s->filestream,(ZPOS64_T)lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
lSeek=0; lSeek=0;
else else
err=UNZ_ERRNO; err=UNZ_ERRNO;
@ -1018,7 +1018,7 @@ local int unz64local_GetCurrentFileInfoInternal (unzFile file,
if (lSeek!=0) if (lSeek!=0)
{ {
if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) if (ZSEEK64(s->z_filefunc, s->filestream,(ZPOS64_T)lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
lSeek=0; lSeek=0;
else else
err=UNZ_ERRNO; err=UNZ_ERRNO;
@ -1090,7 +1090,7 @@ local int unz64local_GetCurrentFileInfoInternal (unzFile file,
if (lSeek!=0) if (lSeek!=0)
{ {
if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) if (ZSEEK64(s->z_filefunc, s->filestream,(ZPOS64_T)lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
lSeek=0; lSeek=0;
else else
err=UNZ_ERRNO; err=UNZ_ERRNO;
@ -1566,6 +1566,7 @@ extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED; pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
else else
{ {
TRYFREE(pfile_in_zip_read_info->read_buffer);
TRYFREE(pfile_in_zip_read_info); TRYFREE(pfile_in_zip_read_info);
return err; return err;
} }
@ -1586,6 +1587,7 @@ extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
pfile_in_zip_read_info->stream_initialised=Z_DEFLATED; pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;
else else
{ {
TRYFREE(pfile_in_zip_read_info->read_buffer);
TRYFREE(pfile_in_zip_read_info); TRYFREE(pfile_in_zip_read_info);
return err; return err;
} }
@ -1767,7 +1769,7 @@ extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len)
if ((pfile_in_zip_read_info->stream.avail_in == 0) && if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
(pfile_in_zip_read_info->rest_read_compressed == 0)) (pfile_in_zip_read_info->rest_read_compressed == 0))
return (iRead==0) ? UNZ_EOF : iRead; return (iRead==0) ? UNZ_EOF : (int)iRead;
if (pfile_in_zip_read_info->stream.avail_out < if (pfile_in_zip_read_info->stream.avail_out <
pfile_in_zip_read_info->stream.avail_in) pfile_in_zip_read_info->stream.avail_in)
@ -1857,6 +1859,9 @@ extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len)
err = Z_DATA_ERROR; err = Z_DATA_ERROR;
uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
/* Detect overflow, because z_stream.total_out is uLong (32 bits) */
if (uTotalOutAfter<uTotalOutBefore)
uTotalOutAfter += 1LL << 32; /* Add maximum value of uLong + 1 */
uOutThis = uTotalOutAfter-uTotalOutBefore; uOutThis = uTotalOutAfter-uTotalOutBefore;
pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis; pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
@ -1871,14 +1876,14 @@ extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len)
iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
if (err==Z_STREAM_END) if (err==Z_STREAM_END)
return (iRead==0) ? UNZ_EOF : iRead; return (iRead==0) ? UNZ_EOF : (int)iRead;
if (err!=Z_OK) if (err!=Z_OK)
break; break;
} }
} }
if (err==Z_OK) if (err==Z_OK)
return iRead; return (int)iRead;
return err; return err;
} }

12
contrib/zlib/contrib/minizip/unzip.h
View File

@ -83,12 +83,12 @@ typedef voidp unzFile;
/* tm_unz contain date/time info */ /* tm_unz contain date/time info */
typedef struct tm_unz_s typedef struct tm_unz_s
{ {
uInt tm_sec; /* seconds after the minute - [0,59] */ int tm_sec; /* seconds after the minute - [0,59] */
uInt tm_min; /* minutes after the hour - [0,59] */ int tm_min; /* minutes after the hour - [0,59] */
uInt tm_hour; /* hours since midnight - [0,23] */ int tm_hour; /* hours since midnight - [0,23] */
uInt tm_mday; /* day of the month - [1,31] */ int tm_mday; /* day of the month - [1,31] */
uInt tm_mon; /* months since January - [0,11] */ int tm_mon; /* months since January - [0,11] */
uInt tm_year; /* years - [1980..2044] */ int tm_year; /* years - [1980..2044] */
} tm_unz; } tm_unz;
/* unz_global_info structure contain global data about the ZIPfile /* unz_global_info structure contain global data about the ZIPfile

43
contrib/zlib/contrib/minizip/zip.c
View File

@ -158,7 +158,7 @@ typedef struct
#ifndef NOCRYPT #ifndef NOCRYPT
unsigned long keys[3]; /* keys defining the pseudo-random sequence */ unsigned long keys[3]; /* keys defining the pseudo-random sequence */
const z_crc_t* pcrc_32_tab; const z_crc_t* pcrc_32_tab;
int crypt_header_size; unsigned crypt_header_size;
#endif #endif
} curfile64_info; } curfile64_info;
@ -301,7 +301,7 @@ local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def,
} }
} }
if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,(uLong)nbByte)!=(uLong)nbByte)
return ZIP_ERRNO; return ZIP_ERRNO;
else else
return ZIP_OK; return ZIP_OK;
@ -337,8 +337,8 @@ local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm)
else if (year>=80) else if (year>=80)
year-=80; year-=80;
return return
(uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | (uLong) (((uLong)(ptm->tm_mday) + (32 * (uLong)(ptm->tm_mon+1)) + (512 * year)) << 16) |
((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); (((uLong)ptm->tm_sec/2) + (32 * (uLong)ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
} }
@ -522,12 +522,12 @@ local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_f
if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
{ {
uPosFound = uReadPos+i; uPosFound = uReadPos+(unsigned)i;
break; break;
} }
if (uPosFound!=0) if (uPosFound!=0)
break; break;
} }
TRYFREE(buf); TRYFREE(buf);
return uPosFound; return uPosFound;
@ -586,7 +586,7 @@ local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
// Signature "0x07064b50" Zip64 end of central directory locater // Signature "0x07064b50" Zip64 end of central directory locater
if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07)) if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
{ {
uPosFound = uReadPos+i; uPosFound = uReadPos+(unsigned)i;
break; break;
} }
} }
@ -637,7 +637,7 @@ local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib
return relativeOffset; return relativeOffset;
} }
int LoadCentralDirectoryRecord(zip64_internal* pziinit) local int LoadCentralDirectoryRecord(zip64_internal* pziinit)
{ {
int err=ZIP_OK; int err=ZIP_OK;
ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
@ -955,7 +955,7 @@ extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append)
return zipOpen3(pathname,append,NULL,NULL); return zipOpen3(pathname,append,NULL,NULL);
} }
int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local) local int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local)
{ {
/* write the local header */ /* write the local header */
int err; int err;
@ -1034,8 +1034,8 @@ int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_ex
// Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file) // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream); zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2); err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)HeaderID,2);
err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2); err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)DataSize,2);
err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8); err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8); err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
@ -1471,11 +1471,6 @@ extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned in
{ {
uLong uTotalOutBefore = zi->ci.stream.total_out; uLong uTotalOutBefore = zi->ci.stream.total_out;
err=deflate(&zi->ci.stream, Z_NO_FLUSH); err=deflate(&zi->ci.stream, Z_NO_FLUSH);
if(uTotalOutBefore > zi->ci.stream.total_out)
{
int bBreak = 0;
bBreak++;
}
zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
} }
@ -1516,7 +1511,7 @@ extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_s
zip64_internal* zi; zip64_internal* zi;
ZPOS64_T compressed_size; ZPOS64_T compressed_size;
uLong invalidValue = 0xffffffff; uLong invalidValue = 0xffffffff;
short datasize = 0; unsigned datasize = 0;
int err=ZIP_OK; int err=ZIP_OK;
if (file == NULL) if (file == NULL)
@ -1752,7 +1747,7 @@ extern int ZEXPORT zipCloseFileInZip (zipFile file)
return zipCloseFileInZipRaw (file,0,0); return zipCloseFileInZipRaw (file,0,0);
} }
int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip) local int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip)
{ {
int err = ZIP_OK; int err = ZIP_OK;
ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset; ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset;
@ -1774,7 +1769,7 @@ int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eo
return err; return err;
} }
int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) local int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
{ {
int err = ZIP_OK; int err = ZIP_OK;
@ -1813,7 +1808,7 @@ int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centra
} }
return err; return err;
} }
int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip) local int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
{ {
int err = ZIP_OK; int err = ZIP_OK;
@ -1861,7 +1856,7 @@ int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir,
return err; return err;
} }
int Write_GlobalComment(zip64_internal* zi, const char* global_comment) local int Write_GlobalComment(zip64_internal* zi, const char* global_comment)
{ {
int err = ZIP_OK; int err = ZIP_OK;
uInt size_global_comment = 0; uInt size_global_comment = 0;
@ -1959,10 +1954,10 @@ extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHe
int retVal = ZIP_OK; int retVal = ZIP_OK;
if(pData == NULL || *dataLen < 4) if(pData == NULL || dataLen == NULL || *dataLen < 4)
return ZIP_PARAMERROR; return ZIP_PARAMERROR;
pNewHeader = (char*)ALLOC(*dataLen); pNewHeader = (char*)ALLOC((unsigned)*dataLen);
pTmp = pNewHeader; pTmp = pNewHeader;
while(p < (pData + *dataLen)) while(p < (pData + *dataLen))

17
contrib/zlib/contrib/minizip/zip.h
View File

@ -88,12 +88,12 @@ typedef voidp zipFile;
/* tm_zip contain date/time info */ /* tm_zip contain date/time info */
typedef struct tm_zip_s typedef struct tm_zip_s
{ {
uInt tm_sec; /* seconds after the minute - [0,59] */ int tm_sec; /* seconds after the minute - [0,59] */
uInt tm_min; /* minutes after the hour - [0,59] */ int tm_min; /* minutes after the hour - [0,59] */
uInt tm_hour; /* hours since midnight - [0,23] */ int tm_hour; /* hours since midnight - [0,23] */
uInt tm_mday; /* day of the month - [1,31] */ int tm_mday; /* day of the month - [1,31] */
uInt tm_mon; /* months since January - [0,11] */ int tm_mon; /* months since January - [0,11] */
uInt tm_year; /* years - [1980..2044] */ int tm_year; /* years - [1980..2044] */
} tm_zip; } tm_zip;
typedef struct typedef struct
@ -144,6 +144,11 @@ extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
zipcharpc* globalcomment, zipcharpc* globalcomment,
zlib_filefunc64_def* pzlib_filefunc_def)); zlib_filefunc64_def* pzlib_filefunc_def));
extern zipFile ZEXPORT zipOpen3 OF((const void *pathname,
int append,
zipcharpc* globalcomment,
zlib_filefunc64_32_def* pzlib_filefunc64_32_def));
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
const char* filename, const char* filename,
const zip_fileinfo* zipfi, const zip_fileinfo* zipfi,

2
contrib/zlib/contrib/pascal/zlibpas.pas
View File

@ -10,7 +10,7 @@ unit zlibpas;
interface interface
const const
ZLIB_VERSION = '1.2.11'; ZLIB_VERSION = '1.2.13';
ZLIB_VERNUM = $12a0; ZLIB_VERNUM = $12a0;
type type

2
contrib/zlib/contrib/puff/README
View File

@ -38,7 +38,7 @@ Then you can call puff() to decompress a deflate stream that is in memory in
its entirety at source, to a sufficiently sized block of memory for the its entirety at source, to a sufficiently sized block of memory for the
decompressed data at dest. puff() is the only external symbol in puff.c The decompressed data at dest. puff() is the only external symbol in puff.c The
only C library functions that puff.c needs are setjmp() and longjmp(), which only C library functions that puff.c needs are setjmp() and longjmp(), which
are used to simplify error checking in the code to improve readabilty. puff.c are used to simplify error checking in the code to improve readability. puff.c
does no memory allocation, and uses less than 2K bytes off of the stack. does no memory allocation, and uses less than 2K bytes off of the stack.
If destlen is not enough space for the uncompressed data, then inflate will If destlen is not enough space for the uncompressed data, then inflate will

4
contrib/zlib/contrib/puff/puff.c
View File

@ -43,7 +43,7 @@
* - Use pointers instead of long to specify source and * - Use pointers instead of long to specify source and
* destination sizes to avoid arbitrary 4 GB limits * destination sizes to avoid arbitrary 4 GB limits
* 1.2 17 Mar 2002 - Add faster version of decode(), doubles speed (!), * 1.2 17 Mar 2002 - Add faster version of decode(), doubles speed (!),
* but leave simple version for readabilty * but leave simple version for readability
* - Make sure invalid distances detected if pointers * - Make sure invalid distances detected if pointers
* are 16 bits * are 16 bits
* - Fix fixed codes table error * - Fix fixed codes table error
@ -624,7 +624,7 @@ local int fixed(struct state *s)
* are themselves compressed using Huffman codes and run-length encoding. In * are themselves compressed using Huffman codes and run-length encoding. In
* the list of code lengths, a 0 symbol means no code, a 1..15 symbol means * the list of code lengths, a 0 symbol means no code, a 1..15 symbol means
* that length, and the symbols 16, 17, and 18 are run-length instructions. * that length, and the symbols 16, 17, and 18 are run-length instructions.
* Each of 16, 17, and 18 are follwed by extra bits to define the length of * Each of 16, 17, and 18 are followed by extra bits to define the length of
* the run. 16 copies the last length 3 to 6 times. 17 represents 3 to 10 * the run. 16 copies the last length 3 to 6 times. 17 represents 3 to 10
* zero lengths, and 18 represents 11 to 138 zero lengths. Unused symbols * zero lengths, and 18 represents 11 to 138 zero lengths. Unused symbols
* are common, hence the special coding for zero lengths. * are common, hence the special coding for zero lengths.

2
contrib/zlib/contrib/puff/pufftest.c
View File

@ -143,7 +143,7 @@ int main(int argc, char **argv)
len - sourcelen); len - sourcelen);
} }
/* if requested, inflate again and write decompressd data to stdout */ /* if requested, inflate again and write decompressed data to stdout */
if (put && ret == 0) { if (put && ret == 0) {
if (fail) if (fail)
destlen >>= 1; destlen >>= 1;

2
contrib/zlib/contrib/testzlib/testzlib.txt
View File

@ -7,4 +7,4 @@ copy to a directory file from :
- contrib/masmx64 - contrib/masmx64
- contrib/vstudio/vc7 - contrib/vstudio/vc7
and open testzlib8.sln and open testzlib8.sln

5
contrib/zlib/contrib/vstudio/readme.txt
View File

@ -1,4 +1,4 @@
Building instructions for the DLL versions of Zlib 1.2.11 Building instructions for the DLL versions of Zlib 1.2.13
======================================================== ========================================================
This directory contains projects that build zlib and minizip using This directory contains projects that build zlib and minizip using
@ -17,9 +17,6 @@ More information can be found at this site.
Build instructions for Visual Studio 2008 (32 bits or 64 bits) Build instructions for Visual Studio 2008 (32 bits or 64 bits)
-------------------------------------------------------------- --------------------------------------------------------------
- Decompress current zlib, including all contrib/* files - Decompress current zlib, including all contrib/* files
- Compile assembly code (with Visual Studio Command Prompt) by running:
bld_ml64.bat (in contrib\masmx64)
bld_ml32.bat (in contrib\masmx86)
- Open contrib\vstudio\vc9\zlibvc.sln with Microsoft Visual C++ 2008 - Open contrib\vstudio\vc9\zlibvc.sln with Microsoft Visual C++ 2008
- Or run: vcbuild /rebuild contrib\vstudio\vc9\zlibvc.sln "Release|Win32" - Or run: vcbuild /rebuild contrib\vstudio\vc9\zlibvc.sln "Release|Win32"

8
contrib/zlib/contrib/vstudio/vc10/zlib.rc
View File

@ -2,8 +2,8 @@
#define IDR_VERSION1 1 #define IDR_VERSION1 1
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
FILEVERSION 1, 2, 11, 0 FILEVERSION 1, 2, 13, 0
PRODUCTVERSION 1, 2, 11, 0 PRODUCTVERSION 1, 2, 13, 0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0 FILEFLAGS 0
FILEOS VOS_DOS_WINDOWS32 FILEOS VOS_DOS_WINDOWS32
@ -17,12 +17,12 @@ BEGIN
BEGIN BEGIN
VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
VALUE "FileVersion", "1.2.11\0" VALUE "FileVersion", "1.2.13\0"
VALUE "InternalName", "zlib\0" VALUE "InternalName", "zlib\0"
VALUE "OriginalFilename", "zlibwapi.dll\0" VALUE "OriginalFilename", "zlibwapi.dll\0"
VALUE "ProductName", "ZLib.DLL\0" VALUE "ProductName", "ZLib.DLL\0"
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0" VALUE "LegalCopyright", "(C) 1995-2022 Jean-loup Gailly & Mark Adler\0"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

311
contrib/zlib/contrib/vstudio/vc10/zlibvc.def
View File

@ -1,153 +1,158 @@
LIBRARY LIBRARY
; zlib data compression and ZIP file I/O library ; zlib data compression and ZIP file I/O library
VERSION 1.2 VERSION 1.2
EXPORTS EXPORTS
adler32 @1 adler32 @1
compress @2 compress @2
crc32 @3 crc32 @3
deflate @4 deflate @4
deflateCopy @5 deflateCopy @5
deflateEnd @6 deflateEnd @6
deflateInit2_ @7 deflateInit2_ @7
deflateInit_ @8 deflateInit_ @8
deflateParams @9 deflateParams @9
deflateReset @10 deflateReset @10
deflateSetDictionary @11 deflateSetDictionary @11
gzclose @12 gzclose @12
gzdopen @13 gzdopen @13
gzerror @14 gzerror @14
gzflush @15 gzflush @15
gzopen @16 gzopen @16
gzread @17 gzread @17
gzwrite @18 gzwrite @18
inflate @19 inflate @19
inflateEnd @20 inflateEnd @20
inflateInit2_ @21 inflateInit2_ @21
inflateInit_ @22 inflateInit_ @22
inflateReset @23 inflateReset @23
inflateSetDictionary @24 inflateSetDictionary @24
inflateSync @25 inflateSync @25
uncompress @26 uncompress @26
zlibVersion @27 zlibVersion @27
gzprintf @28 gzprintf @28
gzputc @29 gzputc @29
gzgetc @30 gzgetc @30
gzseek @31 gzseek @31
gzrewind @32 gzrewind @32
gztell @33 gztell @33
gzeof @34 gzeof @34
gzsetparams @35 gzsetparams @35
zError @36 zError @36
inflateSyncPoint @37 inflateSyncPoint @37
get_crc_table @38 get_crc_table @38
compress2 @39 compress2 @39
gzputs @40 gzputs @40
gzgets @41 gzgets @41
inflateCopy @42 inflateCopy @42
inflateBackInit_ @43 inflateBackInit_ @43
inflateBack @44 inflateBack @44
inflateBackEnd @45 inflateBackEnd @45
compressBound @46 compressBound @46
deflateBound @47 deflateBound @47
gzclearerr @48 gzclearerr @48
gzungetc @49 gzungetc @49
zlibCompileFlags @50 zlibCompileFlags @50
deflatePrime @51 deflatePrime @51
deflatePending @52 deflatePending @52
unzOpen @61 unzOpen @61
unzClose @62 unzClose @62
unzGetGlobalInfo @63 unzGetGlobalInfo @63
unzGetCurrentFileInfo @64 unzGetCurrentFileInfo @64
unzGoToFirstFile @65 unzGoToFirstFile @65
unzGoToNextFile @66 unzGoToNextFile @66
unzOpenCurrentFile @67 unzOpenCurrentFile @67
unzReadCurrentFile @68 unzReadCurrentFile @68
unzOpenCurrentFile3 @69 unzOpenCurrentFile3 @69
unztell @70 unztell @70
unzeof @71 unzeof @71
unzCloseCurrentFile @72 unzCloseCurrentFile @72
unzGetGlobalComment @73 unzGetGlobalComment @73
unzStringFileNameCompare @74 unzStringFileNameCompare @74
unzLocateFile @75 unzLocateFile @75
unzGetLocalExtrafield @76 unzGetLocalExtrafield @76
unzOpen2 @77 unzOpen2 @77
unzOpenCurrentFile2 @78 unzOpenCurrentFile2 @78
unzOpenCurrentFilePassword @79 unzOpenCurrentFilePassword @79
zipOpen @80 zipOpen @80
zipOpenNewFileInZip @81 zipOpenNewFileInZip @81
zipWriteInFileInZip @82 zipWriteInFileInZip @82
zipCloseFileInZip @83 zipCloseFileInZip @83
zipClose @84 zipClose @84
zipOpenNewFileInZip2 @86 zipOpenNewFileInZip2 @86
zipCloseFileInZipRaw @87 zipCloseFileInZipRaw @87
zipOpen2 @88 zipOpen2 @88
zipOpenNewFileInZip3 @89 zipOpenNewFileInZip3 @89
unzGetFilePos @100 unzGetFilePos @100
unzGoToFilePos @101 unzGoToFilePos @101
fill_win32_filefunc @110 fill_win32_filefunc @110
; zlibwapi v1.2.4 added: ; zlibwapi v1.2.4 added:
fill_win32_filefunc64 @111 fill_win32_filefunc64 @111
fill_win32_filefunc64A @112 fill_win32_filefunc64A @112
fill_win32_filefunc64W @113 fill_win32_filefunc64W @113
unzOpen64 @120 unzOpen64 @120
unzOpen2_64 @121 unzOpen2_64 @121
unzGetGlobalInfo64 @122 unzGetGlobalInfo64 @122
unzGetCurrentFileInfo64 @124 unzGetCurrentFileInfo64 @124
unzGetCurrentFileZStreamPos64 @125 unzGetCurrentFileZStreamPos64 @125
unztell64 @126 unztell64 @126
unzGetFilePos64 @127 unzGetFilePos64 @127
unzGoToFilePos64 @128 unzGoToFilePos64 @128
zipOpen64 @130 zipOpen64 @130
zipOpen2_64 @131 zipOpen2_64 @131
zipOpenNewFileInZip64 @132 zipOpenNewFileInZip64 @132
zipOpenNewFileInZip2_64 @133 zipOpenNewFileInZip2_64 @133
zipOpenNewFileInZip3_64 @134 zipOpenNewFileInZip3_64 @134
zipOpenNewFileInZip4_64 @135 zipOpenNewFileInZip4_64 @135
zipCloseFileInZipRaw64 @136 zipCloseFileInZipRaw64 @136
; zlib1 v1.2.4 added: ; zlib1 v1.2.4 added:
adler32_combine @140 adler32_combine @140
crc32_combine @142 crc32_combine @142
deflateSetHeader @144 deflateSetHeader @144
deflateTune @145 deflateTune @145
gzbuffer @146 gzbuffer @146
gzclose_r @147 gzclose_r @147
gzclose_w @148 gzclose_w @148
gzdirect @149 gzdirect @149
gzoffset @150 gzoffset @150
inflateGetHeader @156 inflateGetHeader @156
inflateMark @157 inflateMark @157
inflatePrime @158 inflatePrime @158
inflateReset2 @159 inflateReset2 @159
inflateUndermine @160 inflateUndermine @160
; zlib1 v1.2.6 added: ; zlib1 v1.2.6 added:
gzgetc_ @161 gzgetc_ @161
inflateResetKeep @163 inflateResetKeep @163
deflateResetKeep @164 deflateResetKeep @164
; zlib1 v1.2.7 added: ; zlib1 v1.2.7 added:
gzopen_w @165 gzopen_w @165
; zlib1 v1.2.8 added: ; zlib1 v1.2.8 added:
inflateGetDictionary @166 inflateGetDictionary @166
gzvprintf @167 gzvprintf @167
; zlib1 v1.2.9 added: ; zlib1 v1.2.9 added:
inflateCodesUsed @168 inflateCodesUsed @168
inflateValidate @169 inflateValidate @169
uncompress2 @170 uncompress2 @170
gzfread @171 gzfread @171
gzfwrite @172 gzfwrite @172
deflateGetDictionary @173 deflateGetDictionary @173
adler32_z @174 adler32_z @174
crc32_z @175 crc32_z @175
; zlib1 v1.2.12 added:
crc32_combine_gen @176
crc32_combine_gen64 @177
crc32_combine_op @178

8
contrib/zlib/contrib/vstudio/vc11/zlib.rc
View File

@ -2,8 +2,8 @@
#define IDR_VERSION1 1 #define IDR_VERSION1 1
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
FILEVERSION 1, 2, 11, 0 FILEVERSION 1, 2, 13, 0
PRODUCTVERSION 1, 2, 11, 0 PRODUCTVERSION 1, 2, 13, 0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0 FILEFLAGS 0
FILEOS VOS_DOS_WINDOWS32 FILEOS VOS_DOS_WINDOWS32
@ -17,12 +17,12 @@ BEGIN
BEGIN BEGIN
VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
VALUE "FileVersion", "1.2.11\0" VALUE "FileVersion", "1.2.13\0"
VALUE "InternalName", "zlib\0" VALUE "InternalName", "zlib\0"
VALUE "OriginalFilename", "zlibwapi.dll\0" VALUE "OriginalFilename", "zlibwapi.dll\0"
VALUE "ProductName", "ZLib.DLL\0" VALUE "ProductName", "ZLib.DLL\0"
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0" VALUE "LegalCopyright", "(C) 1995-2022 Jean-loup Gailly & Mark Adler\0"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

311
contrib/zlib/contrib/vstudio/vc11/zlibvc.def
View File

@ -1,153 +1,158 @@
LIBRARY LIBRARY
; zlib data compression and ZIP file I/O library ; zlib data compression and ZIP file I/O library
VERSION 1.2 VERSION 1.2
EXPORTS EXPORTS
adler32 @1 adler32 @1
compress @2 compress @2
crc32 @3 crc32 @3
deflate @4 deflate @4
deflateCopy @5 deflateCopy @5
deflateEnd @6 deflateEnd @6
deflateInit2_ @7 deflateInit2_ @7
deflateInit_ @8 deflateInit_ @8
deflateParams @9 deflateParams @9
deflateReset @10 deflateReset @10
deflateSetDictionary @11 deflateSetDictionary @11
gzclose @12 gzclose @12
gzdopen @13 gzdopen @13
gzerror @14 gzerror @14
gzflush @15 gzflush @15
gzopen @16 gzopen @16
gzread @17 gzread @17
gzwrite @18 gzwrite @18
inflate @19 inflate @19
inflateEnd @20 inflateEnd @20
inflateInit2_ @21 inflateInit2_ @21
inflateInit_ @22 inflateInit_ @22
inflateReset @23 inflateReset @23
inflateSetDictionary @24 inflateSetDictionary @24
inflateSync @25 inflateSync @25
uncompress @26 uncompress @26
zlibVersion @27 zlibVersion @27
gzprintf @28 gzprintf @28
gzputc @29 gzputc @29
gzgetc @30 gzgetc @30
gzseek @31 gzseek @31
gzrewind @32 gzrewind @32
gztell @33 gztell @33
gzeof @34 gzeof @34
gzsetparams @35 gzsetparams @35
zError @36 zError @36
inflateSyncPoint @37 inflateSyncPoint @37
get_crc_table @38 get_crc_table @38
compress2 @39 compress2 @39
gzputs @40 gzputs @40
gzgets @41 gzgets @41
inflateCopy @42 inflateCopy @42
inflateBackInit_ @43 inflateBackInit_ @43
inflateBack @44 inflateBack @44
inflateBackEnd @45 inflateBackEnd @45
compressBound @46 compressBound @46
deflateBound @47 deflateBound @47
gzclearerr @48 gzclearerr @48
gzungetc @49 gzungetc @49
zlibCompileFlags @50 zlibCompileFlags @50
deflatePrime @51 deflatePrime @51
deflatePending @52 deflatePending @52
unzOpen @61 unzOpen @61
unzClose @62 unzClose @62
unzGetGlobalInfo @63 unzGetGlobalInfo @63
unzGetCurrentFileInfo @64 unzGetCurrentFileInfo @64
unzGoToFirstFile @65 unzGoToFirstFile @65
unzGoToNextFile @66 unzGoToNextFile @66
unzOpenCurrentFile @67 unzOpenCurrentFile @67
unzReadCurrentFile @68 unzReadCurrentFile @68
unzOpenCurrentFile3 @69 unzOpenCurrentFile3 @69
unztell @70 unztell @70
unzeof @71 unzeof @71
unzCloseCurrentFile @72 unzCloseCurrentFile @72
unzGetGlobalComment @73 unzGetGlobalComment @73
unzStringFileNameCompare @74 unzStringFileNameCompare @74
unzLocateFile @75 unzLocateFile @75
unzGetLocalExtrafield @76 unzGetLocalExtrafield @76
unzOpen2 @77 unzOpen2 @77
unzOpenCurrentFile2 @78 unzOpenCurrentFile2 @78
unzOpenCurrentFilePassword @79 unzOpenCurrentFilePassword @79
zipOpen @80 zipOpen @80
zipOpenNewFileInZip @81 zipOpenNewFileInZip @81
zipWriteInFileInZip @82 zipWriteInFileInZip @82
zipCloseFileInZip @83 zipCloseFileInZip @83
zipClose @84 zipClose @84
zipOpenNewFileInZip2 @86 zipOpenNewFileInZip2 @86
zipCloseFileInZipRaw @87 zipCloseFileInZipRaw @87
zipOpen2 @88 zipOpen2 @88
zipOpenNewFileInZip3 @89 zipOpenNewFileInZip3 @89
unzGetFilePos @100 unzGetFilePos @100
unzGoToFilePos @101 unzGoToFilePos @101
fill_win32_filefunc @110 fill_win32_filefunc @110
; zlibwapi v1.2.4 added: ; zlibwapi v1.2.4 added:
fill_win32_filefunc64 @111 fill_win32_filefunc64 @111
fill_win32_filefunc64A @112 fill_win32_filefunc64A @112
fill_win32_filefunc64W @113 fill_win32_filefunc64W @113
unzOpen64 @120 unzOpen64 @120
unzOpen2_64 @121 unzOpen2_64 @121
unzGetGlobalInfo64 @122 unzGetGlobalInfo64 @122
unzGetCurrentFileInfo64 @124 unzGetCurrentFileInfo64 @124
unzGetCurrentFileZStreamPos64 @125 unzGetCurrentFileZStreamPos64 @125
unztell64 @126 unztell64 @126
unzGetFilePos64 @127 unzGetFilePos64 @127
unzGoToFilePos64 @128 unzGoToFilePos64 @128
zipOpen64 @130 zipOpen64 @130
zipOpen2_64 @131 zipOpen2_64 @131
zipOpenNewFileInZip64 @132 zipOpenNewFileInZip64 @132
zipOpenNewFileInZip2_64 @133 zipOpenNewFileInZip2_64 @133
zipOpenNewFileInZip3_64 @134 zipOpenNewFileInZip3_64 @134
zipOpenNewFileInZip4_64 @135 zipOpenNewFileInZip4_64 @135
zipCloseFileInZipRaw64 @136 zipCloseFileInZipRaw64 @136
; zlib1 v1.2.4 added: ; zlib1 v1.2.4 added:
adler32_combine @140 adler32_combine @140
crc32_combine @142 crc32_combine @142
deflateSetHeader @144 deflateSetHeader @144
deflateTune @145 deflateTune @145
gzbuffer @146 gzbuffer @146
gzclose_r @147 gzclose_r @147
gzclose_w @148 gzclose_w @148
gzdirect @149 gzdirect @149
gzoffset @150 gzoffset @150
inflateGetHeader @156 inflateGetHeader @156
inflateMark @157 inflateMark @157
inflatePrime @158 inflatePrime @158
inflateReset2 @159 inflateReset2 @159
inflateUndermine @160 inflateUndermine @160
; zlib1 v1.2.6 added: ; zlib1 v1.2.6 added:
gzgetc_ @161 gzgetc_ @161
inflateResetKeep @163 inflateResetKeep @163
deflateResetKeep @164 deflateResetKeep @164
; zlib1 v1.2.7 added: ; zlib1 v1.2.7 added:
gzopen_w @165 gzopen_w @165
; zlib1 v1.2.8 added: ; zlib1 v1.2.8 added:
inflateGetDictionary @166 inflateGetDictionary @166
gzvprintf @167 gzvprintf @167
; zlib1 v1.2.9 added: ; zlib1 v1.2.9 added:
inflateCodesUsed @168 inflateCodesUsed @168
inflateValidate @169 inflateValidate @169
uncompress2 @170 uncompress2 @170
gzfread @171 gzfread @171
gzfwrite @172 gzfwrite @172
deflateGetDictionary @173 deflateGetDictionary @173
adler32_z @174 adler32_z @174
crc32_z @175 crc32_z @175
; zlib1 v1.2.12 added:
crc32_combine_gen @176
crc32_combine_gen64 @177
crc32_combine_op @178

8
contrib/zlib/contrib/vstudio/vc12/zlib.rc
View File

@ -2,8 +2,8 @@
#define IDR_VERSION1 1 #define IDR_VERSION1 1
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
FILEVERSION 1, 2, 11, 0 FILEVERSION 1, 2, 13, 0
PRODUCTVERSION 1, 2, 11, 0 PRODUCTVERSION 1, 2, 13, 0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0 FILEFLAGS 0
FILEOS VOS_DOS_WINDOWS32 FILEOS VOS_DOS_WINDOWS32
@ -17,12 +17,12 @@ BEGIN
BEGIN BEGIN
VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
VALUE "FileVersion", "1.2.11\0" VALUE "FileVersion", "1.2.13\0"
VALUE "InternalName", "zlib\0" VALUE "InternalName", "zlib\0"
VALUE "OriginalFilename", "zlibwapi.dll\0" VALUE "OriginalFilename", "zlibwapi.dll\0"
VALUE "ProductName", "ZLib.DLL\0" VALUE "ProductName", "ZLib.DLL\0"
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0" VALUE "LegalCopyright", "(C) 1995-2022 Jean-loup Gailly & Mark Adler\0"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

311
contrib/zlib/contrib/vstudio/vc12/zlibvc.def
View File

@ -1,153 +1,158 @@
LIBRARY LIBRARY
; zlib data compression and ZIP file I/O library ; zlib data compression and ZIP file I/O library
VERSION 1.2 VERSION 1.2
EXPORTS EXPORTS
adler32 @1 adler32 @1
compress @2 compress @2
crc32 @3 crc32 @3
deflate @4 deflate @4
deflateCopy @5 deflateCopy @5
deflateEnd @6 deflateEnd @6
deflateInit2_ @7 deflateInit2_ @7
deflateInit_ @8 deflateInit_ @8
deflateParams @9 deflateParams @9
deflateReset @10 deflateReset @10
deflateSetDictionary @11 deflateSetDictionary @11
gzclose @12 gzclose @12
gzdopen @13 gzdopen @13
gzerror @14 gzerror @14
gzflush @15 gzflush @15
gzopen @16 gzopen @16
gzread @17 gzread @17
gzwrite @18 gzwrite @18
inflate @19 inflate @19
inflateEnd @20 inflateEnd @20
inflateInit2_ @21 inflateInit2_ @21
inflateInit_ @22 inflateInit_ @22
inflateReset @23 inflateReset @23
inflateSetDictionary @24 inflateSetDictionary @24
inflateSync @25 inflateSync @25
uncompress @26 uncompress @26
zlibVersion @27 zlibVersion @27
gzprintf @28 gzprintf @28
gzputc @29 gzputc @29
gzgetc @30 gzgetc @30
gzseek @31 gzseek @31
gzrewind @32 gzrewind @32
gztell @33 gztell @33
gzeof @34 gzeof @34
gzsetparams @35 gzsetparams @35
zError @36 zError @36
inflateSyncPoint @37 inflateSyncPoint @37
get_crc_table @38 get_crc_table @38
compress2 @39 compress2 @39
gzputs @40 gzputs @40
gzgets @41 gzgets @41
inflateCopy @42 inflateCopy @42
inflateBackInit_ @43 inflateBackInit_ @43
inflateBack @44 inflateBack @44
inflateBackEnd @45 inflateBackEnd @45
compressBound @46 compressBound @46
deflateBound @47 deflateBound @47
gzclearerr @48 gzclearerr @48
gzungetc @49 gzungetc @49
zlibCompileFlags @50 zlibCompileFlags @50
deflatePrime @51 deflatePrime @51
deflatePending @52 deflatePending @52
unzOpen @61 unzOpen @61
unzClose @62 unzClose @62
unzGetGlobalInfo @63 unzGetGlobalInfo @63
unzGetCurrentFileInfo @64 unzGetCurrentFileInfo @64
unzGoToFirstFile @65 unzGoToFirstFile @65
unzGoToNextFile @66 unzGoToNextFile @66
unzOpenCurrentFile @67 unzOpenCurrentFile @67
unzReadCurrentFile @68 unzReadCurrentFile @68
unzOpenCurrentFile3 @69 unzOpenCurrentFile3 @69
unztell @70 unztell @70
unzeof @71 unzeof @71
unzCloseCurrentFile @72 unzCloseCurrentFile @72
unzGetGlobalComment @73 unzGetGlobalComment @73
unzStringFileNameCompare @74 unzStringFileNameCompare @74
unzLocateFile @75 unzLocateFile @75
unzGetLocalExtrafield @76 unzGetLocalExtrafield @76
unzOpen2 @77 unzOpen2 @77
unzOpenCurrentFile2 @78 unzOpenCurrentFile2 @78
unzOpenCurrentFilePassword @79 unzOpenCurrentFilePassword @79
zipOpen @80 zipOpen @80
zipOpenNewFileInZip @81 zipOpenNewFileInZip @81
zipWriteInFileInZip @82 zipWriteInFileInZip @82
zipCloseFileInZip @83 zipCloseFileInZip @83
zipClose @84 zipClose @84
zipOpenNewFileInZip2 @86 zipOpenNewFileInZip2 @86
zipCloseFileInZipRaw @87 zipCloseFileInZipRaw @87
zipOpen2 @88 zipOpen2 @88
zipOpenNewFileInZip3 @89 zipOpenNewFileInZip3 @89
unzGetFilePos @100 unzGetFilePos @100
unzGoToFilePos @101 unzGoToFilePos @101
fill_win32_filefunc @110 fill_win32_filefunc @110
; zlibwapi v1.2.4 added: ; zlibwapi v1.2.4 added:
fill_win32_filefunc64 @111 fill_win32_filefunc64 @111
fill_win32_filefunc64A @112 fill_win32_filefunc64A @112
fill_win32_filefunc64W @113 fill_win32_filefunc64W @113
unzOpen64 @120 unzOpen64 @120
unzOpen2_64 @121 unzOpen2_64 @121
unzGetGlobalInfo64 @122 unzGetGlobalInfo64 @122
unzGetCurrentFileInfo64 @124 unzGetCurrentFileInfo64 @124
unzGetCurrentFileZStreamPos64 @125 unzGetCurrentFileZStreamPos64 @125
unztell64 @126 unztell64 @126
unzGetFilePos64 @127 unzGetFilePos64 @127
unzGoToFilePos64 @128 unzGoToFilePos64 @128
zipOpen64 @130 zipOpen64 @130
zipOpen2_64 @131 zipOpen2_64 @131
zipOpenNewFileInZip64 @132 zipOpenNewFileInZip64 @132
zipOpenNewFileInZip2_64 @133 zipOpenNewFileInZip2_64 @133
zipOpenNewFileInZip3_64 @134 zipOpenNewFileInZip3_64 @134
zipOpenNewFileInZip4_64 @135 zipOpenNewFileInZip4_64 @135
zipCloseFileInZipRaw64 @136 zipCloseFileInZipRaw64 @136
; zlib1 v1.2.4 added: ; zlib1 v1.2.4 added:
adler32_combine @140 adler32_combine @140
crc32_combine @142 crc32_combine @142
deflateSetHeader @144 deflateSetHeader @144
deflateTune @145 deflateTune @145
gzbuffer @146 gzbuffer @146
gzclose_r @147 gzclose_r @147
gzclose_w @148 gzclose_w @148
gzdirect @149 gzdirect @149
gzoffset @150 gzoffset @150
inflateGetHeader @156 inflateGetHeader @156
inflateMark @157 inflateMark @157
inflatePrime @158 inflatePrime @158
inflateReset2 @159 inflateReset2 @159
inflateUndermine @160 inflateUndermine @160
; zlib1 v1.2.6 added: ; zlib1 v1.2.6 added:
gzgetc_ @161 gzgetc_ @161
inflateResetKeep @163 inflateResetKeep @163
deflateResetKeep @164 deflateResetKeep @164
; zlib1 v1.2.7 added: ; zlib1 v1.2.7 added:
gzopen_w @165 gzopen_w @165
; zlib1 v1.2.8 added: ; zlib1 v1.2.8 added:
inflateGetDictionary @166 inflateGetDictionary @166
gzvprintf @167 gzvprintf @167
; zlib1 v1.2.9 added: ; zlib1 v1.2.9 added:
inflateCodesUsed @168 inflateCodesUsed @168
inflateValidate @169 inflateValidate @169
uncompress2 @170 uncompress2 @170
gzfread @171 gzfread @171
gzfwrite @172 gzfwrite @172
deflateGetDictionary @173 deflateGetDictionary @173
adler32_z @174 adler32_z @174
crc32_z @175 crc32_z @175
; zlib1 v1.2.12 added:
crc32_combine_gen @176
crc32_combine_gen64 @177
crc32_combine_op @178

8
contrib/zlib/contrib/vstudio/vc14/zlib.rc
View File

@ -2,8 +2,8 @@
#define IDR_VERSION1 1 #define IDR_VERSION1 1
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
FILEVERSION 1, 2, 11, 0 FILEVERSION 1, 2, 13, 0
PRODUCTVERSION 1, 2, 11, 0 PRODUCTVERSION 1, 2, 13, 0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0 FILEFLAGS 0
FILEOS VOS_DOS_WINDOWS32 FILEOS VOS_DOS_WINDOWS32
@ -17,12 +17,12 @@ BEGIN
BEGIN BEGIN
VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
VALUE "FileVersion", "1.2.11\0" VALUE "FileVersion", "1.2.13\0"
VALUE "InternalName", "zlib\0" VALUE "InternalName", "zlib\0"
VALUE "OriginalFilename", "zlibwapi.dll\0" VALUE "OriginalFilename", "zlibwapi.dll\0"
VALUE "ProductName", "ZLib.DLL\0" VALUE "ProductName", "ZLib.DLL\0"
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0" VALUE "LegalCopyright", "(C) 1995-2022 Jean-loup Gailly & Mark Adler\0"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

311
contrib/zlib/contrib/vstudio/vc14/zlibvc.def
View File

@ -1,153 +1,158 @@
LIBRARY LIBRARY
; zlib data compression and ZIP file I/O library ; zlib data compression and ZIP file I/O library
VERSION 1.2 VERSION 1.2
EXPORTS EXPORTS
adler32 @1 adler32 @1
compress @2 compress @2
crc32 @3 crc32 @3
deflate @4 deflate @4
deflateCopy @5 deflateCopy @5
deflateEnd @6 deflateEnd @6
deflateInit2_ @7 deflateInit2_ @7
deflateInit_ @8 deflateInit_ @8
deflateParams @9 deflateParams @9
deflateReset @10 deflateReset @10
deflateSetDictionary @11 deflateSetDictionary @11
gzclose @12 gzclose @12
gzdopen @13 gzdopen @13
gzerror @14 gzerror @14
gzflush @15 gzflush @15
gzopen @16 gzopen @16
gzread @17 gzread @17
gzwrite @18 gzwrite @18
inflate @19 inflate @19
inflateEnd @20 inflateEnd @20
inflateInit2_ @21 inflateInit2_ @21
inflateInit_ @22 inflateInit_ @22
inflateReset @23 inflateReset @23
inflateSetDictionary @24 inflateSetDictionary @24
inflateSync @25 inflateSync @25
uncompress @26 uncompress @26
zlibVersion @27 zlibVersion @27
gzprintf @28 gzprintf @28
gzputc @29 gzputc @29
gzgetc @30 gzgetc @30
gzseek @31 gzseek @31
gzrewind @32 gzrewind @32
gztell @33 gztell @33
gzeof @34 gzeof @34
gzsetparams @35 gzsetparams @35
zError @36 zError @36
inflateSyncPoint @37 inflateSyncPoint @37
get_crc_table @38 get_crc_table @38
compress2 @39 compress2 @39
gzputs @40 gzputs @40
gzgets @41 gzgets @41
inflateCopy @42 inflateCopy @42
inflateBackInit_ @43 inflateBackInit_ @43
inflateBack @44 inflateBack @44
inflateBackEnd @45 inflateBackEnd @45
compressBound @46 compressBound @46
deflateBound @47 deflateBound @47
gzclearerr @48 gzclearerr @48
gzungetc @49 gzungetc @49
zlibCompileFlags @50 zlibCompileFlags @50
deflatePrime @51 deflatePrime @51
deflatePending @52 deflatePending @52
unzOpen @61 unzOpen @61
unzClose @62 unzClose @62
unzGetGlobalInfo @63 unzGetGlobalInfo @63
unzGetCurrentFileInfo @64 unzGetCurrentFileInfo @64
unzGoToFirstFile @65 unzGoToFirstFile @65
unzGoToNextFile @66 unzGoToNextFile @66
unzOpenCurrentFile @67 unzOpenCurrentFile @67
unzReadCurrentFile @68 unzReadCurrentFile @68
unzOpenCurrentFile3 @69 unzOpenCurrentFile3 @69
unztell @70 unztell @70
unzeof @71 unzeof @71
unzCloseCurrentFile @72 unzCloseCurrentFile @72
unzGetGlobalComment @73 unzGetGlobalComment @73
unzStringFileNameCompare @74 unzStringFileNameCompare @74
unzLocateFile @75 unzLocateFile @75
unzGetLocalExtrafield @76 unzGetLocalExtrafield @76
unzOpen2 @77 unzOpen2 @77
unzOpenCurrentFile2 @78 unzOpenCurrentFile2 @78
unzOpenCurrentFilePassword @79 unzOpenCurrentFilePassword @79
zipOpen @80 zipOpen @80
zipOpenNewFileInZip @81 zipOpenNewFileInZip @81
zipWriteInFileInZip @82 zipWriteInFileInZip @82
zipCloseFileInZip @83 zipCloseFileInZip @83
zipClose @84 zipClose @84
zipOpenNewFileInZip2 @86 zipOpenNewFileInZip2 @86
zipCloseFileInZipRaw @87 zipCloseFileInZipRaw @87
zipOpen2 @88 zipOpen2 @88
zipOpenNewFileInZip3 @89 zipOpenNewFileInZip3 @89
unzGetFilePos @100 unzGetFilePos @100
unzGoToFilePos @101 unzGoToFilePos @101
fill_win32_filefunc @110 fill_win32_filefunc @110
; zlibwapi v1.2.4 added: ; zlibwapi v1.2.4 added:
fill_win32_filefunc64 @111 fill_win32_filefunc64 @111
fill_win32_filefunc64A @112 fill_win32_filefunc64A @112
fill_win32_filefunc64W @113 fill_win32_filefunc64W @113
unzOpen64 @120 unzOpen64 @120
unzOpen2_64 @121 unzOpen2_64 @121
unzGetGlobalInfo64 @122 unzGetGlobalInfo64 @122
unzGetCurrentFileInfo64 @124 unzGetCurrentFileInfo64 @124
unzGetCurrentFileZStreamPos64 @125 unzGetCurrentFileZStreamPos64 @125
unztell64 @126 unztell64 @126
unzGetFilePos64 @127 unzGetFilePos64 @127
unzGoToFilePos64 @128 unzGoToFilePos64 @128
zipOpen64 @130 zipOpen64 @130
zipOpen2_64 @131 zipOpen2_64 @131
zipOpenNewFileInZip64 @132 zipOpenNewFileInZip64 @132
zipOpenNewFileInZip2_64 @133 zipOpenNewFileInZip2_64 @133
zipOpenNewFileInZip3_64 @134 zipOpenNewFileInZip3_64 @134
zipOpenNewFileInZip4_64 @135 zipOpenNewFileInZip4_64 @135
zipCloseFileInZipRaw64 @136 zipCloseFileInZipRaw64 @136
; zlib1 v1.2.4 added: ; zlib1 v1.2.4 added:
adler32_combine @140 adler32_combine @140
crc32_combine @142 crc32_combine @142
deflateSetHeader @144 deflateSetHeader @144
deflateTune @145 deflateTune @145
gzbuffer @146 gzbuffer @146
gzclose_r @147 gzclose_r @147
gzclose_w @148 gzclose_w @148
gzdirect @149 gzdirect @149
gzoffset @150 gzoffset @150
inflateGetHeader @156 inflateGetHeader @156
inflateMark @157 inflateMark @157
inflatePrime @158 inflatePrime @158
inflateReset2 @159 inflateReset2 @159
inflateUndermine @160 inflateUndermine @160
; zlib1 v1.2.6 added: ; zlib1 v1.2.6 added:
gzgetc_ @161 gzgetc_ @161
inflateResetKeep @163 inflateResetKeep @163
deflateResetKeep @164 deflateResetKeep @164
; zlib1 v1.2.7 added: ; zlib1 v1.2.7 added:
gzopen_w @165 gzopen_w @165
; zlib1 v1.2.8 added: ; zlib1 v1.2.8 added:
inflateGetDictionary @166 inflateGetDictionary @166
gzvprintf @167 gzvprintf @167
; zlib1 v1.2.9 added: ; zlib1 v1.2.9 added:
inflateCodesUsed @168 inflateCodesUsed @168
inflateValidate @169 inflateValidate @169
uncompress2 @170 uncompress2 @170
gzfread @171 gzfread @171
gzfwrite @172 gzfwrite @172
deflateGetDictionary @173 deflateGetDictionary @173
adler32_z @174 adler32_z @174
crc32_z @175 crc32_z @175
; zlib1 v1.2.12 added:
crc32_combine_gen @176
crc32_combine_gen64 @177
crc32_combine_op @178

8
contrib/zlib/contrib/vstudio/vc9/zlib.rc
View File

@ -2,8 +2,8 @@
#define IDR_VERSION1 1 #define IDR_VERSION1 1
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
FILEVERSION 1, 2, 11, 0 FILEVERSION 1, 2, 13, 0
PRODUCTVERSION 1, 2, 11, 0 PRODUCTVERSION 1, 2, 13, 0
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
FILEFLAGS 0 FILEFLAGS 0
FILEOS VOS_DOS_WINDOWS32 FILEOS VOS_DOS_WINDOWS32
@ -17,12 +17,12 @@ BEGIN
BEGIN BEGIN
VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0" VALUE "FileDescription", "zlib data compression and ZIP file I/O library\0"
VALUE "FileVersion", "1.2.11\0" VALUE "FileVersion", "1.2.13\0"
VALUE "InternalName", "zlib\0" VALUE "InternalName", "zlib\0"
VALUE "OriginalFilename", "zlibwapi.dll\0" VALUE "OriginalFilename", "zlibwapi.dll\0"
VALUE "ProductName", "ZLib.DLL\0" VALUE "ProductName", "ZLib.DLL\0"
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0" VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
VALUE "LegalCopyright", "(C) 1995-2017 Jean-loup Gailly & Mark Adler\0" VALUE "LegalCopyright", "(C) 1995-2022 Jean-loup Gailly & Mark Adler\0"
END END
END END
BLOCK "VarFileInfo" BLOCK "VarFileInfo"

311
contrib/zlib/contrib/vstudio/vc9/zlibvc.def
View File

@ -1,153 +1,158 @@
LIBRARY LIBRARY
; zlib data compression and ZIP file I/O library ; zlib data compression and ZIP file I/O library
VERSION 1.2 VERSION 1.2
EXPORTS EXPORTS
adler32 @1 adler32 @1
compress @2 compress @2
crc32 @3 crc32 @3
deflate @4 deflate @4
deflateCopy @5 deflateCopy @5
deflateEnd @6 deflateEnd @6
deflateInit2_ @7 deflateInit2_ @7
deflateInit_ @8 deflateInit_ @8
deflateParams @9 deflateParams @9
deflateReset @10 deflateReset @10
deflateSetDictionary @11 deflateSetDictionary @11
gzclose @12 gzclose @12
gzdopen @13 gzdopen @13
gzerror @14 gzerror @14
gzflush @15 gzflush @15
gzopen @16 gzopen @16
gzread @17 gzread @17
gzwrite @18 gzwrite @18
inflate @19 inflate @19
inflateEnd @20 inflateEnd @20
inflateInit2_ @21 inflateInit2_ @21
inflateInit_ @22 inflateInit_ @22
inflateReset @23 inflateReset @23
inflateSetDictionary @24 inflateSetDictionary @24
inflateSync @25 inflateSync @25
uncompress @26 uncompress @26
zlibVersion @27 zlibVersion @27
gzprintf @28 gzprintf @28
gzputc @29 gzputc @29
gzgetc @30 gzgetc @30
gzseek @31 gzseek @31
gzrewind @32 gzrewind @32
gztell @33 gztell @33
gzeof @34 gzeof @34
gzsetparams @35 gzsetparams @35
zError @36 zError @36
inflateSyncPoint @37 inflateSyncPoint @37
get_crc_table @38 get_crc_table @38
compress2 @39 compress2 @39
gzputs @40 gzputs @40
gzgets @41 gzgets @41
inflateCopy @42 inflateCopy @42
inflateBackInit_ @43 inflateBackInit_ @43
inflateBack @44 inflateBack @44
inflateBackEnd @45 inflateBackEnd @45
compressBound @46 compressBound @46
deflateBound @47 deflateBound @47
gzclearerr @48 gzclearerr @48
gzungetc @49 gzungetc @49
zlibCompileFlags @50 zlibCompileFlags @50
deflatePrime @51 deflatePrime @51
deflatePending @52 deflatePending @52
unzOpen @61 unzOpen @61
unzClose @62 unzClose @62
unzGetGlobalInfo @63 unzGetGlobalInfo @63
unzGetCurrentFileInfo @64 unzGetCurrentFileInfo @64
unzGoToFirstFile @65 unzGoToFirstFile @65
unzGoToNextFile @66 unzGoToNextFile @66
unzOpenCurrentFile @67 unzOpenCurrentFile @67
unzReadCurrentFile @68 unzReadCurrentFile @68
unzOpenCurrentFile3 @69 unzOpenCurrentFile3 @69
unztell @70 unztell @70
unzeof @71 unzeof @71
unzCloseCurrentFile @72 unzCloseCurrentFile @72
unzGetGlobalComment @73 unzGetGlobalComment @73
unzStringFileNameCompare @74 unzStringFileNameCompare @74
unzLocateFile @75 unzLocateFile @75
unzGetLocalExtrafield @76 unzGetLocalExtrafield @76
unzOpen2 @77 unzOpen2 @77
unzOpenCurrentFile2 @78 unzOpenCurrentFile2 @78
unzOpenCurrentFilePassword @79 unzOpenCurrentFilePassword @79
zipOpen @80 zipOpen @80
zipOpenNewFileInZip @81 zipOpenNewFileInZip @81
zipWriteInFileInZip @82 zipWriteInFileInZip @82
zipCloseFileInZip @83 zipCloseFileInZip @83
zipClose @84 zipClose @84
zipOpenNewFileInZip2 @86 zipOpenNewFileInZip2 @86
zipCloseFileInZipRaw @87 zipCloseFileInZipRaw @87
zipOpen2 @88 zipOpen2 @88
zipOpenNewFileInZip3 @89 zipOpenNewFileInZip3 @89
unzGetFilePos @100 unzGetFilePos @100
unzGoToFilePos @101 unzGoToFilePos @101
fill_win32_filefunc @110 fill_win32_filefunc @110
; zlibwapi v1.2.4 added: ; zlibwapi v1.2.4 added:
fill_win32_filefunc64 @111 fill_win32_filefunc64 @111
fill_win32_filefunc64A @112 fill_win32_filefunc64A @112
fill_win32_filefunc64W @113 fill_win32_filefunc64W @113
unzOpen64 @120 unzOpen64 @120
unzOpen2_64 @121 unzOpen2_64 @121
unzGetGlobalInfo64 @122 unzGetGlobalInfo64 @122
unzGetCurrentFileInfo64 @124 unzGetCurrentFileInfo64 @124
unzGetCurrentFileZStreamPos64 @125 unzGetCurrentFileZStreamPos64 @125
unztell64 @126 unztell64 @126
unzGetFilePos64 @127 unzGetFilePos64 @127
unzGoToFilePos64 @128 unzGoToFilePos64 @128
zipOpen64 @130 zipOpen64 @130
zipOpen2_64 @131 zipOpen2_64 @131
zipOpenNewFileInZip64 @132 zipOpenNewFileInZip64 @132
zipOpenNewFileInZip2_64 @133 zipOpenNewFileInZip2_64 @133
zipOpenNewFileInZip3_64 @134 zipOpenNewFileInZip3_64 @134
zipOpenNewFileInZip4_64 @135 zipOpenNewFileInZip4_64 @135
zipCloseFileInZipRaw64 @136 zipCloseFileInZipRaw64 @136
; zlib1 v1.2.4 added: ; zlib1 v1.2.4 added:
adler32_combine @140 adler32_combine @140
crc32_combine @142 crc32_combine @142
deflateSetHeader @144 deflateSetHeader @144
deflateTune @145 deflateTune @145
gzbuffer @146 gzbuffer @146
gzclose_r @147 gzclose_r @147
gzclose_w @148 gzclose_w @148
gzdirect @149 gzdirect @149
gzoffset @150 gzoffset @150
inflateGetHeader @156 inflateGetHeader @156
inflateMark @157 inflateMark @157
inflatePrime @158 inflatePrime @158
inflateReset2 @159 inflateReset2 @159
inflateUndermine @160 inflateUndermine @160
; zlib1 v1.2.6 added: ; zlib1 v1.2.6 added:
gzgetc_ @161 gzgetc_ @161
inflateResetKeep @163 inflateResetKeep @163
deflateResetKeep @164 deflateResetKeep @164
; zlib1 v1.2.7 added: ; zlib1 v1.2.7 added:
gzopen_w @165 gzopen_w @165
; zlib1 v1.2.8 added: ; zlib1 v1.2.8 added:
inflateGetDictionary @166 inflateGetDictionary @166
gzvprintf @167 gzvprintf @167
; zlib1 v1.2.9 added: ; zlib1 v1.2.9 added:
inflateCodesUsed @168 inflateCodesUsed @168
inflateValidate @169 inflateValidate @169
uncompress2 @170 uncompress2 @170
gzfread @171 gzfread @171
gzfwrite @172 gzfwrite @172
deflateGetDictionary @173 deflateGetDictionary @173
adler32_z @174 adler32_z @174
crc32_z @175 crc32_z @175
; zlib1 v1.2.12 added:
crc32_combine_gen @176
crc32_combine_gen64 @177
crc32_combine_op @178

1303
contrib/zlib/crc32.c
View File

File diff suppressed because it is too large Load Diff

9877
contrib/zlib/crc32.h
View File

File diff suppressed because it is too large Load Diff

291
contrib/zlib/deflate.c
View File

@ -1,5 +1,5 @@
/* deflate.c -- compress data using the deflation algorithm /* deflate.c -- compress data using the deflation algorithm
* Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler * Copyright (C) 1995-2022 Jean-loup Gailly and Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -52,7 +52,7 @@
#include "deflate.h" #include "deflate.h"
const char deflate_copyright[] = const char deflate_copyright[] =
" deflate 1.2.11.1 Copyright 1995-2017 Jean-loup Gailly and Mark Adler "; " deflate 1.2.13 Copyright 1995-2022 Jean-loup Gailly and Mark Adler ";
/* /*
If you use the zlib library in a product, an acknowledgment is welcome 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 in the documentation of your product. If for some reason you cannot
@ -87,13 +87,7 @@ local void lm_init OF((deflate_state *s));
local void putShortMSB OF((deflate_state *s, uInt b)); local void putShortMSB OF((deflate_state *s, uInt b));
local void flush_pending OF((z_streamp strm)); local void flush_pending OF((z_streamp strm));
local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
#ifdef ASMV
# pragma message("Assembler code may have bugs -- use at your own risk")
void match_init OF((void)); /* asm code initialization */
uInt longest_match OF((deflate_state *s, IPos cur_match));
#else
local uInt longest_match OF((deflate_state *s, IPos cur_match)); local uInt longest_match OF((deflate_state *s, IPos cur_match));
#endif
#ifdef ZLIB_DEBUG #ifdef ZLIB_DEBUG
local void check_match OF((deflate_state *s, IPos start, IPos match, local void check_match OF((deflate_state *s, IPos start, IPos match,
@ -160,7 +154,7 @@ local const config configuration_table[10] = {
* characters, so that a running hash key can be computed from the previous * characters, so that a running hash key can be computed from the previous
* key instead of complete recalculation each time. * key instead of complete recalculation each time.
*/ */
#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask) #define UPDATE_HASH(s,h,c) (h = (((h) << s->hash_shift) ^ (c)) & s->hash_mask)
/* =========================================================================== /* ===========================================================================
@ -191,9 +185,9 @@ local const config configuration_table[10] = {
*/ */
#define CLEAR_HASH(s) \ #define CLEAR_HASH(s) \
do { \ do { \
s->head[s->hash_size-1] = NIL; \ s->head[s->hash_size - 1] = NIL; \
zmemzero((Bytef *)s->head, \ zmemzero((Bytef *)s->head, \
(unsigned)(s->hash_size-1)*sizeof(*s->head)); \ (unsigned)(s->hash_size - 1)*sizeof(*s->head)); \
} while (0) } while (0)
/* =========================================================================== /* ===========================================================================
@ -255,11 +249,6 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
int wrap = 1; int wrap = 1;
static const char my_version[] = ZLIB_VERSION; static const char my_version[] = ZLIB_VERSION;
ushf *overlay;
/* We overlay pending_buf and d_buf+l_buf. This works since the average
* output size for (length,distance) codes is <= 24 bits.
*/
if (version == Z_NULL || version[0] != my_version[0] || if (version == Z_NULL || version[0] != my_version[0] ||
stream_size != sizeof(z_stream)) { stream_size != sizeof(z_stream)) {
return Z_VERSION_ERROR; return Z_VERSION_ERROR;
@ -290,6 +279,8 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
if (windowBits < 0) { /* suppress zlib wrapper */ if (windowBits < 0) { /* suppress zlib wrapper */
wrap = 0; wrap = 0;
if (windowBits < -15)
return Z_STREAM_ERROR;
windowBits = -windowBits; windowBits = -windowBits;
} }
#ifdef GZIP #ifdef GZIP
@ -319,7 +310,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
s->hash_bits = (uInt)memLevel + 7; s->hash_bits = (uInt)memLevel + 7;
s->hash_size = 1 << s->hash_bits; s->hash_size = 1 << s->hash_bits;
s->hash_mask = s->hash_size - 1; s->hash_mask = s->hash_size - 1;
s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); s->hash_shift = ((s->hash_bits + MIN_MATCH-1) / MIN_MATCH);
s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos));
@ -329,9 +320,47 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); /* We overlay pending_buf and sym_buf. This works since the average size
s->pending_buf = (uchf *) overlay; * for length/distance pairs over any compressed block is assured to be 31
s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); * bits or less.
*
* Analysis: The longest fixed codes are a length code of 8 bits plus 5
* extra bits, for lengths 131 to 257. The longest fixed distance codes are
* 5 bits plus 13 extra bits, for distances 16385 to 32768. The longest
* possible fixed-codes length/distance pair is then 31 bits total.
*
* sym_buf starts one-fourth of the way into pending_buf. So there are
* three bytes in sym_buf for every four bytes in pending_buf. Each symbol
* in sym_buf is three bytes -- two for the distance and one for the
* literal/length. As each symbol is consumed, the pointer to the next
* sym_buf value to read moves forward three bytes. From that symbol, up to
* 31 bits are written to pending_buf. The closest the written pending_buf
* bits gets to the next sym_buf symbol to read is just before the last
* code is written. At that time, 31*(n - 2) bits have been written, just
* after 24*(n - 2) bits have been consumed from sym_buf. sym_buf starts at
* 8*n bits into pending_buf. (Note that the symbol buffer fills when n - 1
* symbols are written.) The closest the writing gets to what is unread is
* then n + 14 bits. Here n is lit_bufsize, which is 16384 by default, and
* can range from 128 to 32768.
*
* Therefore, at a minimum, there are 142 bits of space between what is
* written and what is read in the overlain buffers, so the symbols cannot
* be overwritten by the compressed data. That space is actually 139 bits,
* due to the three-bit fixed-code block header.
*
* That covers the case where either Z_FIXED is specified, forcing fixed
* codes, or when the use of fixed codes is chosen, because that choice
* results in a smaller compressed block than dynamic codes. That latter
* condition then assures that the above analysis also covers all dynamic
* blocks. A dynamic-code block will only be chosen to be emitted if it has
* fewer bits than a fixed-code block would for the same set of symbols.
* Therefore its average symbol length is assured to be less than 31. So
* the compressed data for a dynamic block also cannot overwrite the
* symbols from which it is being constructed.
*/
s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 4);
s->pending_buf_size = (ulg)s->lit_bufsize * 4;
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
s->pending_buf == Z_NULL) { s->pending_buf == Z_NULL) {
@ -340,8 +369,12 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
deflateEnd (strm); deflateEnd (strm);
return Z_MEM_ERROR; return Z_MEM_ERROR;
} }
s->d_buf = overlay + s->lit_bufsize/sizeof(ush); s->sym_buf = s->pending_buf + s->lit_bufsize;
s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; s->sym_end = (s->lit_bufsize - 1) * 3;
/* We avoid equality with lit_bufsize*3 because of wraparound at 64K
* on 16 bit machines and because stored blocks are restricted to
* 64K-1 bytes.
*/
s->level = level; s->level = level;
s->strategy = strategy; s->strategy = strategy;
@ -353,7 +386,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
/* ========================================================================= /* =========================================================================
* Check for a valid deflate stream state. Return 0 if ok, 1 if not. * Check for a valid deflate stream state. Return 0 if ok, 1 if not.
*/ */
local int deflateStateCheck (strm) local int deflateStateCheck(strm)
z_streamp strm; z_streamp strm;
{ {
deflate_state *s; deflate_state *s;
@ -376,7 +409,7 @@ local int deflateStateCheck (strm)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) int ZEXPORT deflateSetDictionary(strm, dictionary, dictLength)
z_streamp strm; z_streamp strm;
const Bytef *dictionary; const Bytef *dictionary;
uInt dictLength; uInt dictLength;
@ -445,7 +478,7 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength) int ZEXPORT deflateGetDictionary(strm, dictionary, dictLength)
z_streamp strm; z_streamp strm;
Bytef *dictionary; Bytef *dictionary;
uInt *dictLength; uInt *dictLength;
@ -467,7 +500,7 @@ int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflateResetKeep (strm) int ZEXPORT deflateResetKeep(strm)
z_streamp strm; z_streamp strm;
{ {
deflate_state *s; deflate_state *s;
@ -491,7 +524,7 @@ int ZEXPORT deflateResetKeep (strm)
#ifdef GZIP #ifdef GZIP
s->wrap == 2 ? GZIP_STATE : s->wrap == 2 ? GZIP_STATE :
#endif #endif
s->wrap ? INIT_STATE : BUSY_STATE; INIT_STATE;
strm->adler = strm->adler =
#ifdef GZIP #ifdef GZIP
s->wrap == 2 ? crc32(0L, Z_NULL, 0) : s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
@ -505,7 +538,7 @@ int ZEXPORT deflateResetKeep (strm)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflateReset (strm) int ZEXPORT deflateReset(strm)
z_streamp strm; z_streamp strm;
{ {
int ret; int ret;
@ -517,7 +550,7 @@ int ZEXPORT deflateReset (strm)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflateSetHeader (strm, head) int ZEXPORT deflateSetHeader(strm, head)
z_streamp strm; z_streamp strm;
gz_headerp head; gz_headerp head;
{ {
@ -528,7 +561,7 @@ int ZEXPORT deflateSetHeader (strm, head)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflatePending (strm, pending, bits) int ZEXPORT deflatePending(strm, pending, bits)
unsigned *pending; unsigned *pending;
int *bits; int *bits;
z_streamp strm; z_streamp strm;
@ -542,7 +575,7 @@ int ZEXPORT deflatePending (strm, pending, bits)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflatePrime (strm, bits, value) int ZEXPORT deflatePrime(strm, bits, value)
z_streamp strm; z_streamp strm;
int bits; int bits;
int value; int value;
@ -552,7 +585,8 @@ int ZEXPORT deflatePrime (strm, bits, value)
if (deflateStateCheck(strm)) return Z_STREAM_ERROR; if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
s = strm->state; s = strm->state;
if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) if (bits < 0 || bits > 16 ||
s->sym_buf < s->pending_out + ((Buf_size + 7) >> 3))
return Z_BUF_ERROR; return Z_BUF_ERROR;
do { do {
put = Buf_size - s->bi_valid; put = Buf_size - s->bi_valid;
@ -636,36 +670,50 @@ int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
} }
/* ========================================================================= /* =========================================================================
* For the default windowBits of 15 and memLevel of 8, this function returns * For the default windowBits of 15 and memLevel of 8, this function returns a
* a close to exact, as well as small, upper bound on the compressed size. * close to exact, as well as small, upper bound on the compressed size. This
* They are coded as constants here for a reason--if the #define's are * is an expansion of ~0.03%, plus a small constant.
* changed, then this function needs to be changed as well. The return
* value for 15 and 8 only works for those exact settings.
* *
* For any setting other than those defaults for windowBits and memLevel, * For any setting other than those defaults for windowBits and memLevel, one
* the value returned is a conservative worst case for the maximum expansion * of two worst case bounds is returned. This is at most an expansion of ~4% or
* resulting from using fixed blocks instead of stored blocks, which deflate * ~13%, plus a small constant.
* can emit on compressed data for some combinations of the parameters.
* *
* This function could be more sophisticated to provide closer upper bounds for * Both the 0.03% and 4% derive from the overhead of stored blocks. The first
* every combination of windowBits and memLevel. But even the conservative * one is for stored blocks of 16383 bytes (memLevel == 8), whereas the second
* upper bound of about 14% expansion does not seem onerous for output buffer * is for stored blocks of 127 bytes (the worst case memLevel == 1). The
* allocation. * expansion results from five bytes of header for each stored block.
*
* The larger expansion of 13% results from a window size less than or equal to
* the symbols buffer size (windowBits <= memLevel + 7). In that case some of
* the data being compressed may have slid out of the sliding window, impeding
* a stored block from being emitted. Then the only choice is a fixed or
* dynamic block, where a fixed block limits the maximum expansion to 9 bits
* per 8-bit byte, plus 10 bits for every block. The smallest block size for
* which this can occur is 255 (memLevel == 2).
*
* Shifts are used to approximate divisions, for speed.
*/ */
uLong ZEXPORT deflateBound(strm, sourceLen) uLong ZEXPORT deflateBound(strm, sourceLen)
z_streamp strm; z_streamp strm;
uLong sourceLen; uLong sourceLen;
{ {
deflate_state *s; deflate_state *s;
uLong complen, wraplen; uLong fixedlen, storelen, wraplen;
/* conservative upper bound for compressed data */ /* upper bound for fixed blocks with 9-bit literals and length 255
complen = sourceLen + (memLevel == 2, which is the lowest that may not use stored blocks) --
((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; ~13% overhead plus a small constant */
fixedlen = sourceLen + (sourceLen >> 3) + (sourceLen >> 8) +
(sourceLen >> 9) + 4;
/* if can't get parameters, return conservative bound plus zlib wrapper */ /* upper bound for stored blocks with length 127 (memLevel == 1) --
~4% overhead plus a small constant */
storelen = sourceLen + (sourceLen >> 5) + (sourceLen >> 7) +
(sourceLen >> 11) + 7;
/* if can't get parameters, return larger bound plus a zlib wrapper */
if (deflateStateCheck(strm)) if (deflateStateCheck(strm))
return complen + 6; return (fixedlen > storelen ? fixedlen : storelen) + 6;
/* compute wrapper length */ /* compute wrapper length */
s = strm->state; s = strm->state;
@ -702,11 +750,12 @@ uLong ZEXPORT deflateBound(strm, sourceLen)
wraplen = 6; wraplen = 6;
} }
/* if not default parameters, return conservative bound */ /* if not default parameters, return one of the conservative bounds */
if (s->w_bits != 15 || s->hash_bits != 8 + 7) if (s->w_bits != 15 || s->hash_bits != 8 + 7)
return complen + wraplen; return (s->w_bits <= s->hash_bits ? fixedlen : storelen) + wraplen;
/* default settings: return tight bound for that case */ /* default settings: return tight bound for that case -- ~0.03% overhead
plus a small constant */
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
(sourceLen >> 25) + 13 - 6 + wraplen; (sourceLen >> 25) + 13 - 6 + wraplen;
} }
@ -716,7 +765,7 @@ uLong ZEXPORT deflateBound(strm, sourceLen)
* IN assertion: the stream state is correct and there is enough room in * IN assertion: the stream state is correct and there is enough room in
* pending_buf. * pending_buf.
*/ */
local void putShortMSB (s, b) local void putShortMSB(s, b)
deflate_state *s; deflate_state *s;
uInt b; uInt b;
{ {
@ -763,7 +812,7 @@ local void flush_pending(strm)
} while (0) } while (0)
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflate (strm, flush) int ZEXPORT deflate(strm, flush)
z_streamp strm; z_streamp strm;
int flush; int flush;
{ {
@ -814,9 +863,11 @@ int ZEXPORT deflate (strm, flush)
} }
/* Write the header */ /* Write the header */
if (s->status == INIT_STATE && s->wrap == 0)
s->status = BUSY_STATE;
if (s->status == INIT_STATE) { if (s->status == INIT_STATE) {
/* zlib header */ /* zlib header */
uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; uInt header = (Z_DEFLATED + ((s->w_bits - 8) << 4)) << 8;
uInt level_flags; uInt level_flags;
if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
@ -1076,7 +1127,7 @@ int ZEXPORT deflate (strm, flush)
} }
/* ========================================================================= */ /* ========================================================================= */
int ZEXPORT deflateEnd (strm) int ZEXPORT deflateEnd(strm)
z_streamp strm; z_streamp strm;
{ {
int status; int status;
@ -1102,7 +1153,7 @@ int ZEXPORT deflateEnd (strm)
* To simplify the source, this is not supported for 16-bit MSDOS (which * To simplify the source, this is not supported for 16-bit MSDOS (which
* doesn't have enough memory anyway to duplicate compression states). * doesn't have enough memory anyway to duplicate compression states).
*/ */
int ZEXPORT deflateCopy (dest, source) int ZEXPORT deflateCopy(dest, source)
z_streamp dest; z_streamp dest;
z_streamp source; z_streamp source;
{ {
@ -1111,7 +1162,6 @@ int ZEXPORT deflateCopy (dest, source)
#else #else
deflate_state *ds; deflate_state *ds;
deflate_state *ss; deflate_state *ss;
ushf *overlay;
if (deflateStateCheck(source) || dest == Z_NULL) { if (deflateStateCheck(source) || dest == Z_NULL) {
@ -1131,8 +1181,7 @@ int ZEXPORT deflateCopy (dest, source)
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos));
ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos));
overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); ds->pending_buf = (uchf *) ZALLOC(dest, ds->lit_bufsize, 4);
ds->pending_buf = (uchf *) overlay;
if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
ds->pending_buf == Z_NULL) { ds->pending_buf == Z_NULL) {
@ -1146,8 +1195,7 @@ int ZEXPORT deflateCopy (dest, source)
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); ds->sym_buf = ds->pending_buf + ds->lit_bufsize;
ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
ds->l_desc.dyn_tree = ds->dyn_ltree; ds->l_desc.dyn_tree = ds->dyn_ltree;
ds->d_desc.dyn_tree = ds->dyn_dtree; ds->d_desc.dyn_tree = ds->dyn_dtree;
@ -1194,7 +1242,7 @@ local unsigned read_buf(strm, buf, size)
/* =========================================================================== /* ===========================================================================
* Initialize the "longest match" routines for a new zlib stream * Initialize the "longest match" routines for a new zlib stream
*/ */
local void lm_init (s) local void lm_init(s)
deflate_state *s; deflate_state *s;
{ {
s->window_size = (ulg)2L*s->w_size; s->window_size = (ulg)2L*s->w_size;
@ -1215,11 +1263,6 @@ local void lm_init (s)
s->match_length = s->prev_length = MIN_MATCH-1; s->match_length = s->prev_length = MIN_MATCH-1;
s->match_available = 0; s->match_available = 0;
s->ins_h = 0; s->ins_h = 0;
#ifndef FASTEST
#ifdef ASMV
match_init(); /* initialize the asm code */
#endif
#endif
} }
#ifndef FASTEST #ifndef FASTEST
@ -1232,10 +1275,6 @@ local void lm_init (s)
* string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
* OUT assertion: the match length is not greater than s->lookahead. * OUT assertion: the match length is not greater than s->lookahead.
*/ */
#ifndef ASMV
/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
* match.S. The code will be functionally equivalent.
*/
local uInt longest_match(s, cur_match) local uInt longest_match(s, cur_match)
deflate_state *s; deflate_state *s;
IPos cur_match; /* current match */ IPos cur_match; /* current match */
@ -1260,10 +1299,10 @@ local uInt longest_match(s, cur_match)
*/ */
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
register ush scan_start = *(ushf*)scan; register ush scan_start = *(ushf*)scan;
register ush scan_end = *(ushf*)(scan+best_len-1); register ush scan_end = *(ushf*)(scan + best_len - 1);
#else #else
register Bytef *strend = s->window + s->strstart + MAX_MATCH; register Bytef *strend = s->window + s->strstart + MAX_MATCH;
register Byte scan_end1 = scan[best_len-1]; register Byte scan_end1 = scan[best_len - 1];
register Byte scan_end = scan[best_len]; register Byte scan_end = scan[best_len];
#endif #endif
@ -1281,7 +1320,8 @@ local uInt longest_match(s, cur_match)
*/ */
if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead; if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
"need lookahead");
do { do {
Assert(cur_match < s->strstart, "no future"); Assert(cur_match < s->strstart, "no future");
@ -1299,43 +1339,44 @@ local uInt longest_match(s, cur_match)
/* This code assumes sizeof(unsigned short) == 2. Do not use /* This code assumes sizeof(unsigned short) == 2. Do not use
* UNALIGNED_OK if your compiler uses a different size. * UNALIGNED_OK if your compiler uses a different size.
*/ */
if (*(ushf*)(match+best_len-1) != scan_end || if (*(ushf*)(match + best_len - 1) != scan_end ||
*(ushf*)match != scan_start) continue; *(ushf*)match != scan_start) continue;
/* It is not necessary to compare scan[2] and match[2] since they are /* It is not necessary to compare scan[2] and match[2] since they are
* always equal when the other bytes match, given that the hash keys * always equal when the other bytes match, given that the hash keys
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
* strstart+3, +5, ... up to strstart+257. We check for insufficient * strstart + 3, + 5, up to strstart + 257. We check for insufficient
* lookahead only every 4th comparison; the 128th check will be made * lookahead only every 4th comparison; the 128th check will be made
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is * at strstart + 257. If MAX_MATCH-2 is not a multiple of 8, it is
* necessary to put more guard bytes at the end of the window, or * necessary to put more guard bytes at the end of the window, or
* to check more often for insufficient lookahead. * to check more often for insufficient lookahead.
*/ */
Assert(scan[2] == match[2], "scan[2]?"); Assert(scan[2] == match[2], "scan[2]?");
scan++, match++; scan++, match++;
do { do {
} while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && } while (*(ushf*)(scan += 2) == *(ushf*)(match += 2) &&
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan += 2) == *(ushf*)(match += 2) &&
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan += 2) == *(ushf*)(match += 2) &&
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && *(ushf*)(scan += 2) == *(ushf*)(match += 2) &&
scan < strend); scan < strend);
/* The funny "do {}" generates better code on most compilers */ /* The funny "do {}" generates better code on most compilers */
/* Here, scan <= window+strstart+257 */ /* Here, scan <= window + strstart + 257 */
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); Assert(scan <= s->window + (unsigned)(s->window_size - 1),
"wild scan");
if (*scan == *match) scan++; if (*scan == *match) scan++;
len = (MAX_MATCH - 1) - (int)(strend-scan); len = (MAX_MATCH - 1) - (int)(strend - scan);
scan = strend - (MAX_MATCH-1); scan = strend - (MAX_MATCH-1);
#else /* UNALIGNED_OK */ #else /* UNALIGNED_OK */
if (match[best_len] != scan_end || if (match[best_len] != scan_end ||
match[best_len-1] != scan_end1 || match[best_len - 1] != scan_end1 ||
*match != *scan || *match != *scan ||
*++match != scan[1]) continue; *++match != scan[1]) continue;
/* The check at best_len-1 can be removed because it will be made /* The check at best_len - 1 can be removed because it will be made
* again later. (This heuristic is not always a win.) * again later. (This heuristic is not always a win.)
* It is not necessary to compare scan[2] and match[2] since they * It is not necessary to compare scan[2] and match[2] since they
* are always equal when the other bytes match, given that * are always equal when the other bytes match, given that
@ -1345,7 +1386,7 @@ local uInt longest_match(s, cur_match)
Assert(*scan == *match, "match[2]?"); Assert(*scan == *match, "match[2]?");
/* We check for insufficient lookahead only every 8th comparison; /* We check for insufficient lookahead only every 8th comparison;
* the 256th check will be made at strstart+258. * the 256th check will be made at strstart + 258.
*/ */
do { do {
} while (*++scan == *++match && *++scan == *++match && } while (*++scan == *++match && *++scan == *++match &&
@ -1354,7 +1395,8 @@ local uInt longest_match(s, cur_match)
*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match &&
scan < strend); scan < strend);
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); Assert(scan <= s->window + (unsigned)(s->window_size - 1),
"wild scan");
len = MAX_MATCH - (int)(strend - scan); len = MAX_MATCH - (int)(strend - scan);
scan = strend - MAX_MATCH; scan = strend - MAX_MATCH;
@ -1366,9 +1408,9 @@ local uInt longest_match(s, cur_match)
best_len = len; best_len = len;
if (len >= nice_match) break; if (len >= nice_match) break;
#ifdef UNALIGNED_OK #ifdef UNALIGNED_OK
scan_end = *(ushf*)(scan+best_len-1); scan_end = *(ushf*)(scan + best_len - 1);
#else #else
scan_end1 = scan[best_len-1]; scan_end1 = scan[best_len - 1];
scan_end = scan[best_len]; scan_end = scan[best_len];
#endif #endif
} }
@ -1378,7 +1420,6 @@ local uInt longest_match(s, cur_match)
if ((uInt)best_len <= s->lookahead) return (uInt)best_len; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
return s->lookahead; return s->lookahead;
} }
#endif /* ASMV */
#else /* FASTEST */ #else /* FASTEST */
@ -1399,7 +1440,8 @@ local uInt longest_match(s, cur_match)
*/ */
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
"need lookahead");
Assert(cur_match < s->strstart, "no future"); Assert(cur_match < s->strstart, "no future");
@ -1409,7 +1451,7 @@ local uInt longest_match(s, cur_match)
*/ */
if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
/* The check at best_len-1 can be removed because it will be made /* The check at best_len - 1 can be removed because it will be made
* again later. (This heuristic is not always a win.) * again later. (This heuristic is not always a win.)
* It is not necessary to compare scan[2] and match[2] since they * It is not necessary to compare scan[2] and match[2] since they
* are always equal when the other bytes match, given that * are always equal when the other bytes match, given that
@ -1419,7 +1461,7 @@ local uInt longest_match(s, cur_match)
Assert(*scan == *match, "match[2]?"); Assert(*scan == *match, "match[2]?");
/* We check for insufficient lookahead only every 8th comparison; /* We check for insufficient lookahead only every 8th comparison;
* the 256th check will be made at strstart+258. * the 256th check will be made at strstart + 258.
*/ */
do { do {
} while (*++scan == *++match && *++scan == *++match && } while (*++scan == *++match && *++scan == *++match &&
@ -1428,7 +1470,7 @@ local uInt longest_match(s, cur_match)
*++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match &&
scan < strend); scan < strend);
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); Assert(scan <= s->window + (unsigned)(s->window_size - 1), "wild scan");
len = MAX_MATCH - (int)(strend - scan); len = MAX_MATCH - (int)(strend - scan);
@ -1464,7 +1506,7 @@ local void check_match(s, start, match, length)
z_error("invalid match"); z_error("invalid match");
} }
if (z_verbose > 1) { if (z_verbose > 1) {
fprintf(stderr,"\\[%d,%d]", start-match, length); fprintf(stderr,"\\[%d,%d]", start - match, length);
do { putc(s->window[start++], stderr); } while (--length != 0); do { putc(s->window[start++], stderr); } while (--length != 0);
} }
} }
@ -1510,9 +1552,9 @@ local void fill_window(s)
/* If the window is almost full and there is insufficient lookahead, /* If the window is almost full and there is insufficient lookahead,
* move the upper half to the lower one to make room in the upper half. * move the upper half to the lower one to make room in the upper half.
*/ */
if (s->strstart >= wsize+MAX_DIST(s)) { if (s->strstart >= wsize + MAX_DIST(s)) {
zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more); zmemcpy(s->window, s->window + wsize, (unsigned)wsize - more);
s->match_start -= wsize; s->match_start -= wsize;
s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
s->block_start -= (long) wsize; s->block_start -= (long) wsize;
@ -1643,7 +1685,7 @@ local void fill_window(s)
* *
* deflate_stored() is written to minimize the number of times an input byte is * deflate_stored() is written to minimize the number of times an input byte is
* copied. It is most efficient with large input and output buffers, which * copied. It is most efficient with large input and output buffers, which
* maximizes the opportunites to have a single copy from next_in to next_out. * maximizes the opportunities to have a single copy from next_in to next_out.
*/ */
local block_state deflate_stored(s, flush) local block_state deflate_stored(s, flush)
deflate_state *s; deflate_state *s;
@ -1853,7 +1895,7 @@ local block_state deflate_fast(s, flush)
if (s->lookahead == 0) break; /* flush the current block */ if (s->lookahead == 0) break; /* flush the current block */
} }
/* Insert the string window[strstart .. strstart+2] in the /* Insert the string window[strstart .. strstart + 2] in the
* dictionary, and set hash_head to the head of the hash chain: * dictionary, and set hash_head to the head of the hash chain:
*/ */
hash_head = NIL; hash_head = NIL;
@ -1901,7 +1943,7 @@ local block_state deflate_fast(s, flush)
s->strstart += s->match_length; s->strstart += s->match_length;
s->match_length = 0; s->match_length = 0;
s->ins_h = s->window[s->strstart]; s->ins_h = s->window[s->strstart];
UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); UPDATE_HASH(s, s->ins_h, s->window[s->strstart + 1]);
#if MIN_MATCH != 3 #if MIN_MATCH != 3
Call UPDATE_HASH() MIN_MATCH-3 more times Call UPDATE_HASH() MIN_MATCH-3 more times
#endif #endif
@ -1912,7 +1954,7 @@ local block_state deflate_fast(s, flush)
} else { } else {
/* No match, output a literal byte */ /* No match, output a literal byte */
Tracevv((stderr,"%c", s->window[s->strstart])); Tracevv((stderr,"%c", s->window[s->strstart]));
_tr_tally_lit (s, s->window[s->strstart], bflush); _tr_tally_lit(s, s->window[s->strstart], bflush);
s->lookahead--; s->lookahead--;
s->strstart++; s->strstart++;
} }
@ -1923,7 +1965,7 @@ local block_state deflate_fast(s, flush)
FLUSH_BLOCK(s, 1); FLUSH_BLOCK(s, 1);
return finish_done; return finish_done;
} }
if (s->last_lit) if (s->sym_next)
FLUSH_BLOCK(s, 0); FLUSH_BLOCK(s, 0);
return block_done; return block_done;
} }
@ -1956,7 +1998,7 @@ local block_state deflate_slow(s, flush)
if (s->lookahead == 0) break; /* flush the current block */ if (s->lookahead == 0) break; /* flush the current block */
} }
/* Insert the string window[strstart .. strstart+2] in the /* Insert the string window[strstart .. strstart + 2] in the
* dictionary, and set hash_head to the head of the hash chain: * dictionary, and set hash_head to the head of the hash chain:
*/ */
hash_head = NIL; hash_head = NIL;
@ -1998,17 +2040,17 @@ local block_state deflate_slow(s, flush)
uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
/* Do not insert strings in hash table beyond this. */ /* Do not insert strings in hash table beyond this. */
check_match(s, s->strstart-1, s->prev_match, s->prev_length); check_match(s, s->strstart - 1, s->prev_match, s->prev_length);
_tr_tally_dist(s, s->strstart -1 - s->prev_match, _tr_tally_dist(s, s->strstart - 1 - s->prev_match,
s->prev_length - MIN_MATCH, bflush); s->prev_length - MIN_MATCH, bflush);
/* Insert in hash table all strings up to the end of the match. /* Insert in hash table all strings up to the end of the match.
* strstart-1 and strstart are already inserted. If there is not * strstart - 1 and strstart are already inserted. If there is not
* enough lookahead, the last two strings are not inserted in * enough lookahead, the last two strings are not inserted in
* the hash table. * the hash table.
*/ */
s->lookahead -= s->prev_length-1; s->lookahead -= s->prev_length - 1;
s->prev_length -= 2; s->prev_length -= 2;
do { do {
if (++s->strstart <= max_insert) { if (++s->strstart <= max_insert) {
@ -2026,8 +2068,8 @@ local block_state deflate_slow(s, flush)
* single literal. If there was a match but the current match * single literal. If there was a match but the current match
* is longer, truncate the previous match to a single literal. * is longer, truncate the previous match to a single literal.
*/ */
Tracevv((stderr,"%c", s->window[s->strstart-1])); Tracevv((stderr,"%c", s->window[s->strstart - 1]));
_tr_tally_lit(s, s->window[s->strstart-1], bflush); _tr_tally_lit(s, s->window[s->strstart - 1], bflush);
if (bflush) { if (bflush) {
FLUSH_BLOCK_ONLY(s, 0); FLUSH_BLOCK_ONLY(s, 0);
} }
@ -2045,8 +2087,8 @@ local block_state deflate_slow(s, flush)
} }
Assert (flush != Z_NO_FLUSH, "no flush?"); Assert (flush != Z_NO_FLUSH, "no flush?");
if (s->match_available) { if (s->match_available) {
Tracevv((stderr,"%c", s->window[s->strstart-1])); Tracevv((stderr,"%c", s->window[s->strstart - 1]));
_tr_tally_lit(s, s->window[s->strstart-1], bflush); _tr_tally_lit(s, s->window[s->strstart - 1], bflush);
s->match_available = 0; s->match_available = 0;
} }
s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
@ -2054,7 +2096,7 @@ local block_state deflate_slow(s, flush)
FLUSH_BLOCK(s, 1); FLUSH_BLOCK(s, 1);
return finish_done; return finish_done;
} }
if (s->last_lit) if (s->sym_next)
FLUSH_BLOCK(s, 0); FLUSH_BLOCK(s, 0);
return block_done; return block_done;
} }
@ -2103,7 +2145,8 @@ local block_state deflate_rle(s, flush)
if (s->match_length > s->lookahead) if (s->match_length > s->lookahead)
s->match_length = s->lookahead; s->match_length = s->lookahead;
} }
Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); Assert(scan <= s->window + (uInt)(s->window_size - 1),
"wild scan");
} }
/* Emit match if have run of MIN_MATCH or longer, else emit literal */ /* Emit match if have run of MIN_MATCH or longer, else emit literal */
@ -2118,7 +2161,7 @@ local block_state deflate_rle(s, flush)
} else { } else {
/* No match, output a literal byte */ /* No match, output a literal byte */
Tracevv((stderr,"%c", s->window[s->strstart])); Tracevv((stderr,"%c", s->window[s->strstart]));
_tr_tally_lit (s, s->window[s->strstart], bflush); _tr_tally_lit(s, s->window[s->strstart], bflush);
s->lookahead--; s->lookahead--;
s->strstart++; s->strstart++;
} }
@ -2129,7 +2172,7 @@ local block_state deflate_rle(s, flush)
FLUSH_BLOCK(s, 1); FLUSH_BLOCK(s, 1);
return finish_done; return finish_done;
} }
if (s->last_lit) if (s->sym_next)
FLUSH_BLOCK(s, 0); FLUSH_BLOCK(s, 0);
return block_done; return block_done;
} }
@ -2158,7 +2201,7 @@ local block_state deflate_huff(s, flush)
/* Output a literal byte */ /* Output a literal byte */
s->match_length = 0; s->match_length = 0;
Tracevv((stderr,"%c", s->window[s->strstart])); Tracevv((stderr,"%c", s->window[s->strstart]));
_tr_tally_lit (s, s->window[s->strstart], bflush); _tr_tally_lit(s, s->window[s->strstart], bflush);
s->lookahead--; s->lookahead--;
s->strstart++; s->strstart++;
if (bflush) FLUSH_BLOCK(s, 0); if (bflush) FLUSH_BLOCK(s, 0);
@ -2168,7 +2211,7 @@ local block_state deflate_huff(s, flush)
FLUSH_BLOCK(s, 1); FLUSH_BLOCK(s, 1);
return finish_done; return finish_done;
} }
if (s->last_lit) if (s->sym_next)
FLUSH_BLOCK(s, 0); FLUSH_BLOCK(s, 0);
return block_done; return block_done;
} }

27
contrib/zlib/deflate.h
View File

@ -1,5 +1,5 @@
/* deflate.h -- internal compression state /* deflate.h -- internal compression state
* Copyright (C) 1995-2016 Jean-loup Gailly * Copyright (C) 1995-2018 Jean-loup Gailly
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -217,7 +217,7 @@ typedef struct internal_state {
/* Depth of each subtree used as tie breaker for trees of equal frequency /* Depth of each subtree used as tie breaker for trees of equal frequency
*/ */
uchf *l_buf; /* buffer for literals or lengths */ uchf *sym_buf; /* buffer for distances and literals/lengths */
uInt lit_bufsize; uInt lit_bufsize;
/* Size of match buffer for literals/lengths. There are 4 reasons for /* Size of match buffer for literals/lengths. There are 4 reasons for
@ -239,13 +239,8 @@ typedef struct internal_state {
* - I can't count above 4 * - I can't count above 4
*/ */
uInt last_lit; /* running index in l_buf */ uInt sym_next; /* running index in sym_buf */
uInt sym_end; /* symbol table full when sym_next reaches this */
ushf *d_buf;
/* Buffer for distances. To simplify the code, d_buf and l_buf have
* the same number of elements. To use different lengths, an extra flag
* array would be necessary.
*/
ulg opt_len; /* bit length of current block with optimal trees */ ulg opt_len; /* bit length of current block with optimal trees */
ulg static_len; /* bit length of current block with static trees */ ulg static_len; /* bit length of current block with static trees */
@ -325,20 +320,22 @@ void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
# define _tr_tally_lit(s, c, flush) \ # define _tr_tally_lit(s, c, flush) \
{ uch cc = (c); \ { uch cc = (c); \
s->d_buf[s->last_lit] = 0; \ s->sym_buf[s->sym_next++] = 0; \
s->l_buf[s->last_lit++] = cc; \ s->sym_buf[s->sym_next++] = 0; \
s->sym_buf[s->sym_next++] = cc; \
s->dyn_ltree[cc].Freq++; \ s->dyn_ltree[cc].Freq++; \
flush = (s->last_lit == s->lit_bufsize-1); \ flush = (s->sym_next == s->sym_end); \
} }
# define _tr_tally_dist(s, distance, length, flush) \ # define _tr_tally_dist(s, distance, length, flush) \
{ uch len = (uch)(length); \ { uch len = (uch)(length); \
ush dist = (ush)(distance); \ ush dist = (ush)(distance); \
s->d_buf[s->last_lit] = dist; \ s->sym_buf[s->sym_next++] = (uch)dist; \
s->l_buf[s->last_lit++] = len; \ s->sym_buf[s->sym_next++] = (uch)(dist >> 8); \
s->sym_buf[s->sym_next++] = len; \
dist--; \ dist--; \
s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
s->dyn_dtree[d_code(dist)].Freq++; \ s->dyn_dtree[d_code(dist)].Freq++; \
flush = (s->last_lit == s->lit_bufsize-1); \ flush = (s->sym_next == s->sym_end); \
} }
#else #else
# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) # define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)

3
contrib/zlib/gzguts.h
View File

@ -1,5 +1,5 @@
/* gzguts.h -- zlib internal header definitions for gz* operations /* gzguts.h -- zlib internal header definitions for gz* operations
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler * Copyright (C) 2004-2019 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -190,6 +190,7 @@ typedef struct {
/* just for writing */ /* just for writing */
int level; /* compression level */ int level; /* compression level */
int strategy; /* compression strategy */ int strategy; /* compression strategy */
int reset; /* true if a reset is pending after a Z_FINISH */
/* seek request */ /* seek request */
z_off64_t skip; /* amount to skip (already rewound if backwards) */ z_off64_t skip; /* amount to skip (already rewound if backwards) */
int seek; /* true if seek request pending */ int seek; /* true if seek request pending */

6
contrib/zlib/gzlib.c
View File

@ -1,5 +1,5 @@
/* gzlib.c -- zlib functions common to reading and writing gzip files /* gzlib.c -- zlib functions common to reading and writing gzip files
* Copyright (C) 2004-2017 Mark Adler * Copyright (C) 2004-2019 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -30,7 +30,7 @@ local gzFile gz_open OF((const void *, int, const char *));
The gz_strwinerror function does not change the current setting of The gz_strwinerror function does not change the current setting of
GetLastError. */ GetLastError. */
char ZLIB_INTERNAL *gz_strwinerror (error) char ZLIB_INTERNAL *gz_strwinerror(error)
DWORD error; DWORD error;
{ {
static char buf[1024]; static char buf[1024];
@ -81,6 +81,8 @@ local void gz_reset(state)
state->past = 0; /* have not read past end yet */ state->past = 0; /* have not read past end yet */
state->how = LOOK; /* look for gzip header */ state->how = LOOK; /* look for gzip header */
} }
else /* for writing ... */
state->reset = 0; /* no deflateReset pending */
state->seek = 0; /* no seek request pending */ state->seek = 0; /* no seek request pending */
gz_error(state, Z_OK, NULL); /* clear error */ gz_error(state, Z_OK, NULL); /* clear error */
state->x.pos = 0; /* no uncompressed data yet */ state->x.pos = 0; /* no uncompressed data yet */

10
contrib/zlib/gzread.c
View File

@ -1,5 +1,5 @@
/* gzread.c -- zlib functions for reading gzip files /* gzread.c -- zlib functions for reading gzip files
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler * Copyright (C) 2004-2017 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -157,11 +157,9 @@ local int gz_look(state)
the output buffer is larger than the input buffer, which also assures the output buffer is larger than the input buffer, which also assures
space for gzungetc() */ space for gzungetc() */
state->x.next = state->out; state->x.next = state->out;
if (strm->avail_in) { memcpy(state->x.next, strm->next_in, strm->avail_in);
memcpy(state->x.next, strm->next_in, strm->avail_in); state->x.have = strm->avail_in;
state->x.have = strm->avail_in; strm->avail_in = 0;
strm->avail_in = 0;
}
state->how = COPY; state->how = COPY;
state->direct = 1; state->direct = 1;
return 0; return 0;

27
contrib/zlib/gzwrite.c
View File

@ -1,5 +1,5 @@
/* gzwrite.c -- zlib functions for writing gzip files /* gzwrite.c -- zlib functions for writing gzip files
* Copyright (C) 2004-2017 Mark Adler * Copyright (C) 2004-2019 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -97,6 +97,15 @@ local int gz_comp(state, flush)
return 0; return 0;
} }
/* check for a pending reset */
if (state->reset) {
/* don't start a new gzip member unless there is data to write */
if (strm->avail_in == 0)
return 0;
deflateReset(strm);
state->reset = 0;
}
/* run deflate() on provided input until it produces no more output */ /* run deflate() on provided input until it produces no more output */
ret = Z_OK; ret = Z_OK;
do { do {
@ -134,7 +143,7 @@ local int gz_comp(state, flush)
/* if that completed a deflate stream, allow another to start */ /* if that completed a deflate stream, allow another to start */
if (flush == Z_FINISH) if (flush == Z_FINISH)
deflateReset(strm); state->reset = 1;
/* all done, no errors */ /* all done, no errors */
return 0; return 0;
@ -349,9 +358,9 @@ int ZEXPORT gzputc(file, c)
} }
/* -- see zlib.h -- */ /* -- see zlib.h -- */
int ZEXPORT gzputs(file, str) int ZEXPORT gzputs(file, s)
gzFile file; gzFile file;
const char *str; const char *s;
{ {
z_size_t len, put; z_size_t len, put;
gz_statep state; gz_statep state;
@ -366,12 +375,12 @@ int ZEXPORT gzputs(file, str)
return -1; return -1;
/* write string */ /* write string */
len = strlen(str); len = strlen(s);
if ((int)len < 0 || (unsigned)len != len) { if ((int)len < 0 || (unsigned)len != len) {
gz_error(state, Z_STREAM_ERROR, "string length does not fit in int"); gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
return -1; return -1;
} }
put = gz_write(state, str, len); put = gz_write(state, s, len);
return put < len ? -1 : (int)len; return put < len ? -1 : (int)len;
} }
@ -444,7 +453,7 @@ int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
strm->avail_in = state->size; strm->avail_in = state->size;
if (gz_comp(state, Z_NO_FLUSH) == -1) if (gz_comp(state, Z_NO_FLUSH) == -1)
return state->err; return state->err;
memcpy(state->in, state->in + state->size, left); memmove(state->in, state->in + state->size, left);
strm->next_in = state->in; strm->next_in = state->in;
strm->avail_in = left; strm->avail_in = left;
} }
@ -465,7 +474,7 @@ int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
#else /* !STDC && !Z_HAVE_STDARG_H */ #else /* !STDC && !Z_HAVE_STDARG_H */
/* -- see zlib.h -- */ /* -- see zlib.h -- */
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, int ZEXPORTVA gzprintf(file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
gzFile file; gzFile file;
const char *format; const char *format;
@ -543,7 +552,7 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
strm->avail_in = state->size; strm->avail_in = state->size;
if (gz_comp(state, Z_NO_FLUSH) == -1) if (gz_comp(state, Z_NO_FLUSH) == -1)
return state->err; return state->err;
memcpy(state->in, state->in + state->size, left); memmove(state->in, state->in + state->size, left);
strm->next_in = state->in; strm->next_in = state->in;
strm->avail_in = left; strm->avail_in = left;
} }

20
contrib/zlib/infback.c
View File

@ -1,5 +1,5 @@
/* infback.c -- inflate using a call-back interface /* infback.c -- inflate using a call-back interface
* Copyright (C) 1995-2016 Mark Adler * Copyright (C) 1995-2022 Mark Adler
* For conditions of distribution and use, see copyright notice in zlib.h * For conditions of distribution and use, see copyright notice in zlib.h
*/ */
@ -66,6 +66,7 @@ int stream_size;
state->window = window; state->window = window;
state->wnext = 0; state->wnext = 0;
state->whave = 0; state->whave = 0;
state->sane = 1;
return Z_OK; return Z_OK;
} }
@ -477,6 +478,7 @@ void FAR *out_desc;
} }
Tracev((stderr, "inflate: codes ok\n")); Tracev((stderr, "inflate: codes ok\n"));
state->mode = LEN; state->mode = LEN;
/* fallthrough */
case LEN: case LEN:
/* use inflate_fast() if we have enough input and output */ /* use inflate_fast() if we have enough input and output */
@ -604,25 +606,27 @@ void FAR *out_desc;
break; break;
case DONE: case DONE:
/* inflate stream terminated properly -- write leftover output */ /* inflate stream terminated properly */
ret = Z_STREAM_END; ret = Z_STREAM_END;
if (left < state->wsize) {
if (out(out_desc, state->window, state->wsize - left))
ret = Z_BUF_ERROR;
}
goto inf_leave; goto inf_leave;
case BAD: case BAD:
ret = Z_DATA_ERROR; ret = Z_DATA_ERROR;
goto inf_leave; goto inf_leave;
default: /* can't happen, but makes compilers happy */ default:
/* can't happen, but makes compilers happy */
ret = Z_STREAM_ERROR; ret = Z_STREAM_ERROR;
goto inf_leave; goto inf_leave;
} }
/* Return unused input */ /* Write leftover output and return unused input */
inf_leave: inf_leave:
if (left < state->wsize) {
if (out(out_desc, state->window, state->wsize - left) &&
ret == Z_STREAM_END)
ret = Z_BUF_ERROR;
}
strm->next_in = next; strm->next_in = next;
strm->avail_in = have; strm->avail_in = have;
return ret; return ret;

Some files were not shown because too many files have changed in this diff Show More