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

Merge pull request #3881 from JC3/jc3-spam-killa 

Misc. log output and message fixes
pull/3844/head^2
Kim Kulling 2021-05-11 00:09:16 +02:00 committed by GitHub
parent cdc0bd00ce cb7d3ac598
commit 7ff6144c2c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 90 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
code/AssetLib/AMF/AMFImporter.cpp
View File

@ -268,7 +268,6 @@ void AMFImporter::ParseFile(const std::string &pFile, IOSystem *pIOHandler) {
mXmlParser = new XmlParser();
if (!mXmlParser->parse(file.get())) {
delete mXmlParser;
mXmlParser = nullptr;
throw DeadlyImportError("Failed to create XML reader for file" + pFile + ".");
}

8
code/AssetLib/HMP/HMPLoader.cpp
View File

@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "AssetLib/HMP/HMPLoader.h"
#include "AssetLib/MD2/MD2FileData.h"
#include <assimp/StringUtils.h>
#include <assimp/importerdesc.h>
#include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp>
@ -151,12 +152,7 @@ void HMPImporter::InternReadFile(const std::string &pFile,
InternReadFile_HMP7();
} else {
// Print the magic word to the logger
char szBuffer[5];
szBuffer[0] = ((char *)&iMagic)[0];
szBuffer[1] = ((char *)&iMagic)[1];
szBuffer[2] = ((char *)&iMagic)[2];
szBuffer[3] = ((char *)&iMagic)[3];
szBuffer[4] = '\0';
std::string szBuffer = ai_str_toprintable((const char *)&iMagic, sizeof(iMagic));
delete[] mBuffer;
mBuffer = nullptr;

32
code/AssetLib/MD2/MD2Loader.cpp
View File

@ -53,6 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/IOSystem.hpp>
#include <assimp/scene.h>
#include <assimp/importerdesc.h>
#include <assimp/StringUtils.h>
#include <memory>
@ -148,46 +149,39 @@ void MD2Importer::ValidateHeader( )
if (m_pcHeader->magic != AI_MD2_MAGIC_NUMBER_BE &&
m_pcHeader->magic != AI_MD2_MAGIC_NUMBER_LE)
{
char szBuffer[5];
szBuffer[0] = ((char*)&m_pcHeader->magic)[0];
szBuffer[1] = ((char*)&m_pcHeader->magic)[1];
szBuffer[2] = ((char*)&m_pcHeader->magic)[2];
szBuffer[3] = ((char*)&m_pcHeader->magic)[3];
szBuffer[4] = '\0';
throw DeadlyImportError("Invalid MD2 magic word: should be IDP2, the "
"magic word found is " + std::string(szBuffer));
throw DeadlyImportError("Invalid MD2 magic word: expected IDP2, found ",
ai_str_toprintable((char *)&m_pcHeader->magic, 4));
}
// check file format version
if (m_pcHeader->version != 8)
ASSIMP_LOG_WARN( "Unsupported md2 file version. Continuing happily ...");
ASSIMP_LOG_WARN( "Unsupported MD2 file version. Continuing happily ...");
// check some values whether they are valid
if (0 == m_pcHeader->numFrames)
throw DeadlyImportError( "Invalid md2 file: NUM_FRAMES is 0");
throw DeadlyImportError( "Invalid MD2 file: NUM_FRAMES is 0");
if (m_pcHeader->offsetEnd > (uint32_t)fileSize)
throw DeadlyImportError( "Invalid md2 file: File is too small");
throw DeadlyImportError( "Invalid MD2 file: File is too small");
if (m_pcHeader->numSkins > AI_MAX_ALLOC(MD2::Skin)) {
throw DeadlyImportError("Invalid MD2 header: too many skins, would overflow");
throw DeadlyImportError("Invalid MD2 header: Too many skins, would overflow");
}
if (m_pcHeader->numVertices > AI_MAX_ALLOC(MD2::Vertex)) {
throw DeadlyImportError("Invalid MD2 header: too many vertices, would overflow");
throw DeadlyImportError("Invalid MD2 header: Too many vertices, would overflow");
}
if (m_pcHeader->numTexCoords > AI_MAX_ALLOC(MD2::TexCoord)) {
throw DeadlyImportError("Invalid MD2 header: too many texcoords, would overflow");
throw DeadlyImportError("Invalid MD2 header: Too many texcoords, would overflow");
}
if (m_pcHeader->numTriangles > AI_MAX_ALLOC(MD2::Triangle)) {
throw DeadlyImportError("Invalid MD2 header: too many triangles, would overflow");
throw DeadlyImportError("Invalid MD2 header: Too many triangles, would overflow");
}
if (m_pcHeader->numFrames > AI_MAX_ALLOC(MD2::Frame)) {
throw DeadlyImportError("Invalid MD2 header: too many frames, would overflow");
throw DeadlyImportError("Invalid MD2 header: Too many frames, would overflow");
}
// -1 because Frame already contains one
@ -199,7 +193,7 @@ void MD2Importer::ValidateHeader( )
m_pcHeader->offsetFrames + m_pcHeader->numFrames * frameSize >= fileSize ||
m_pcHeader->offsetEnd > fileSize)
{
throw DeadlyImportError("Invalid MD2 header: some offsets are outside the file");
throw DeadlyImportError("Invalid MD2 header: Some offsets are outside the file");
}
if (m_pcHeader->numSkins > AI_MD2_MAX_SKINS)
@ -210,7 +204,7 @@ void MD2Importer::ValidateHeader( )
ASSIMP_LOG_WARN("The model contains more vertices than Quake 2 supports");
if (m_pcHeader->numFrames <= configFrameID )
throw DeadlyImportError("The requested frame is not existing the file");
throw DeadlyImportError("MD2: The requested frame (", configFrameID, ") does not exist in the file");
}
// ------------------------------------------------------------------------------------------------

13
code/AssetLib/MDC/MDCLoader.cpp
View File

@ -53,6 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/DefaultLogger.hpp>
#include <assimp/IOSystem.hpp>
#include <assimp/Importer.hpp>
#include <assimp/StringUtils.h>
#include <memory>
@ -143,16 +144,8 @@ void MDCImporter::ValidateHeader() {
if (pcHeader->ulIdent != AI_MDC_MAGIC_NUMBER_BE &&
pcHeader->ulIdent != AI_MDC_MAGIC_NUMBER_LE) {
char szBuffer[5];
szBuffer[0] = ((char *)&pcHeader->ulIdent)[0];
szBuffer[1] = ((char *)&pcHeader->ulIdent)[1];
szBuffer[2] = ((char *)&pcHeader->ulIdent)[2];
szBuffer[3] = ((char *)&pcHeader->ulIdent)[3];
szBuffer[4] = '\0';
throw DeadlyImportError("Invalid MDC magic word: should be IDPC, the "
"magic word found is " +
std::string(szBuffer));
throw DeadlyImportError("Invalid MDC magic word: expected IDPC, found ",
ai_str_toprintable((char *)&pcHeader->ulIdent, 4));
}
if (pcHeader->ulVersion != AI_MDC_VERSION) {

2
code/AssetLib/MDL/MDLLoader.cpp
View File

@ -252,7 +252,7 @@ void MDLImporter::InternReadFile(const std::string &pFile,
} else {
// print the magic word to the log file
throw DeadlyImportError("Unknown MDL subformat ", pFile,
". Magic word (", std::string((char *)&iMagicWord, 4), ") is not known");
". Magic word (", ai_str_toprintable((const char *)&iMagicWord, sizeof(iMagicWord)), ") is not known");
}
// Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system

9
code/AssetLib/MMD/MMDPmxParser.cpp
View File

@ -478,8 +478,7 @@ namespace pmx
void PmxSoftBody::Read(std::istream * /*stream*/, PmxSetting * /*setting*/)
{
std::cerr << "Not Implemented Exception" << std::endl;
throw DeadlyImportError("MMD: Not Implemented Exception");
throw DeadlyImportError("MMD: Soft Body support is not implemented.");
}
void PmxModel::Init()
@ -517,14 +516,12 @@ namespace pmx
stream->read((char*) magic, sizeof(char) * 4);
if (magic[0] != 0x50 || magic[1] != 0x4d || magic[2] != 0x58 || magic[3] != 0x20)
{
std::cerr << "invalid magic number." << std::endl;
throw DeadlyImportError("MMD: invalid magic number.");
throw DeadlyImportError("MMD: Invalid magic number.");
}
stream->read((char*) &version, sizeof(float));
if (version != 2.0f && version != 2.1f)
{
std::cerr << "this is not ver2.0 or ver2.1 but " << version << "." << std::endl;
throw DeadlyImportError("MMD: this is not ver2.0 or ver2.1 but ", ai_to_string(version));
throw DeadlyImportError("MMD: Unsupported version (must be 2.0 or 2.1): ", ai_to_string(version));
}
this->setting.Read(stream);

14
code/AssetLib/OpenGEX/OpenGEXImporter.cpp
View File

@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/DefaultIOSystem.h>
#include <assimp/StringComparison.h>
#include <assimp/StringUtils.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/ai_assert.h>
@ -223,6 +224,18 @@ static void propId2StdString(Property *prop, std::string &name, std::string &key
}
}
//------------------------------------------------------------------------------------------------
static void logDDLParserMessage (LogSeverity severity, const std::string &rawmsg) {
std::string msg = ai_str_toprintable(rawmsg);
switch (severity) {
case ddl_debug_msg: ASSIMP_LOG_DEBUG(msg); break;
case ddl_info_msg: ASSIMP_LOG_INFO(msg); break;
case ddl_warn_msg: ASSIMP_LOG_WARN(msg); break;
case ddl_error_msg: ASSIMP_LOG_ERROR(msg); break;
default: ASSIMP_LOG_VERBOSE_DEBUG(msg); break;
}
}
//------------------------------------------------------------------------------------------------
OpenGEXImporter::VertexContainer::VertexContainer() :
m_numColors(0), m_colors(nullptr), m_numUVComps(), m_textureCoords() {
@ -306,6 +319,7 @@ void OpenGEXImporter::InternReadFile(const std::string &filename, aiScene *pScen
pIOHandler->Close(file);
OpenDDLParser myParser;
myParser.setLogCallback(&logDDLParserMessage);
myParser.setBuffer(&buffer[0], buffer.size());
bool success(myParser.parse());
if (success) {

2
code/AssetLib/Ply/PlyLoader.cpp
View File

@ -172,7 +172,7 @@ void PLYImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSy
(headerCheck[1] != 'L' && headerCheck[1] != 'l') ||
(headerCheck[2] != 'Y' && headerCheck[2] != 'y')) {
streamedBuffer.close();
throw DeadlyImportError("Invalid .ply file: Magic number \'ply\' is no there");
throw DeadlyImportError("Invalid .ply file: Incorrect magic number (expected 'ply' or 'PLY').");
}
std::vector<char> mBuffer2;

3
code/AssetLib/Q3D/Q3DLoader.cpp
View File

@ -47,6 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// internal headers
#include "Q3DLoader.h"
#include <assimp/StringUtils.h>
#include <assimp/StreamReader.h>
#include <assimp/fast_atof.h>
#include <assimp/importerdesc.h>
@ -120,7 +121,7 @@ void Q3DImporter::InternReadFile(const std::string &pFile,
// Check the file's signature
if (ASSIMP_strincmp((const char *)stream.GetPtr(), "quick3Do", 8) &&
ASSIMP_strincmp((const char *)stream.GetPtr(), "quick3Ds", 8)) {
throw DeadlyImportError("Not a Quick3D file. Signature string is: ", std::string((const char *)stream.GetPtr(), 8));
throw DeadlyImportError("Not a Quick3D file. Signature string is: ", ai_str_toprintable((const char *)stream.GetPtr(), 8));
}
// Print the file format version

7
code/AssetLib/SIB/SIBImporter.cpp
View File

@ -68,6 +68,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/scene.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/IOSystem.hpp>
#include <assimp/StringUtils.h>
#include <map>
@ -166,14 +167,14 @@ static aiColor3D ReadColor(StreamReaderLE *stream) {
}
static void UnknownChunk(StreamReaderLE * /*stream*/, const SIBChunk &chunk) {
char temp[5] = {
char temp[4] = {
static_cast<char>((chunk.Tag >> 24) & 0xff),
static_cast<char>((chunk.Tag >> 16) & 0xff),
static_cast<char>((chunk.Tag >> 8) & 0xff),
static_cast<char>(chunk.Tag & 0xff), '\0'
static_cast<char>(chunk.Tag & 0xff)
};
ASSIMP_LOG_WARN((Formatter::format(), "SIB: Skipping unknown '", temp, "' chunk."));
ASSIMP_LOG_WARN((Formatter::format(), "SIB: Skipping unknown '", ai_str_toprintable(temp, 4), "' chunk."));
}
// Reads a UTF-16LE string and returns it at UTF-8.

39
contrib/openddlparser/code/OpenDDLParser.cpp
View File

@ -72,13 +72,15 @@ const char *getTypeToken(Value::ValueType type) {
}
static void logInvalidTokenError(char *in, const std::string &exp, OpenDDLParser::logCallback callback) {
std::stringstream stream;
stream << "Invalid token \"" << *in << "\""
<< " expected \"" << exp << "\"" << std::endl;
if (callback) {
std::string full(in);
std::string part(full.substr(0, 50));
stream << part;
std::stringstream stream;
stream << "Invalid token \"" << *in << "\" "
<< "(expected \"" << exp << "\") "
<< "in: \"" << part << "\"";
callback(ddl_error_msg, stream.str());
}
}
static bool isIntegerType(Value::ValueType integerType) {
@ -111,26 +113,8 @@ static DDLNode *createDDLNode(Text *id, OpenDDLParser *parser) {
return node;
}
static void logMessage(LogSeverity severity, const std::string &msg) {
std::string log;
if (ddl_debug_msg == severity) {
log += "Debug:";
} else if (ddl_info_msg == severity) {
log += "Info :";
} else if (ddl_warn_msg == severity) {
log += "Warn :";
} else if (ddl_error_msg == severity) {
log += "Error:";
} else {
log += "None :";
}
log += msg;
std::cout << log;
}
OpenDDLParser::OpenDDLParser() :
m_logCallback(logMessage),
m_logCallback(nullptr),
m_buffer(),
m_stack(),
m_context(nullptr) {
@ -138,7 +122,7 @@ OpenDDLParser::OpenDDLParser() :
}
OpenDDLParser::OpenDDLParser(const char *buffer, size_t len) :
m_logCallback(&logMessage), m_buffer(), m_context(nullptr) {
m_logCallback(nullptr), m_buffer(), m_context(nullptr) {
if (0 != len) {
setBuffer(buffer, len);
}
@ -149,13 +133,8 @@ OpenDDLParser::~OpenDDLParser() {
}
void OpenDDLParser::setLogCallback(logCallback callback) {
if (nullptr != callback) {
// install user-specific log callback
// install user-specific log callback; null = no log callback
m_logCallback = callback;
} else {
// install default log callback
m_logCallback = &logMessage;
}
}
OpenDDLParser::logCallback OpenDDLParser::getLogCallback() const {

27
include/assimp/StringUtils.h
View File

@ -249,4 +249,31 @@ AI_FORCE_INLINE std::string ai_str_toupper(const std::string &in) {
return out;
}
// ---------------------------------------------------------------------------------
/// @brief Make a string printable by replacing all non-printable characters with
/// the specified placeholder character.
/// @param in The incoming string.
/// @param placeholder Placeholder character, default is a question mark.
/// @return The string, with all non-printable characters replaced.
AI_FORCE_INLINE std::string ai_str_toprintable(const std::string &in, char placeholder = '?') {
std::string out(in);
std::transform(out.begin(), out.end(), out.begin(), [placeholder] (unsigned char c) {
return isprint(c) ? (char)c : placeholder;
});
return out;
}
// ---------------------------------------------------------------------------------
/// @brief Make a string printable by replacing all non-printable characters with
/// the specified placeholder character.
/// @param in The incoming string.
/// @param len The length of the incoming string.
/// @param placeholder Placeholder character, default is a question mark.
/// @return The string, with all non-printable characters replaced. Will return an
/// empty string if in is null or len is <= 0.
AI_FORCE_INLINE std::string ai_str_toprintable(const char *in, int len, char placeholder = '?') {
return (in && len > 0) ? ai_str_toprintable(std::string(in, len), placeholder) : std::string();
}
#endif // INCLUDED_AI_STRINGUTILS_H

4
include/assimp/XmlParser.h
View File

@ -139,7 +139,9 @@ public:
if (parse_result.status == pugi::status_ok) {
return true;
} else {
ASSIMP_LOG_DEBUG("Error while parse xml.");
std::ostringstream oss;
oss << "Error while parsing XML: " << parse_result.description() << " @ " << parse_result.offset;
ASSIMP_LOG_DEBUG(oss.str());
return false;
}
}

5
include/assimp/fast_atof.h
View File

@ -29,6 +29,7 @@
#include "StringComparison.h"
#include <assimp/DefaultLogger.hpp>
#include <assimp/Exceptional.h>
#include <assimp/StringUtils.h>
#ifdef _MSC_VER
# include <stdint.h>
@ -193,7 +194,7 @@ uint64_t strtoul10_64( const char* in, const char** out=0, unsigned int* max_ino
if ( *in < '0' || *in > '9' ) {
// The string is known to be bad, so don't risk printing the whole thing.
throw ExceptionType("The string \"", std::string(in).substr(0, 100), "\" cannot be converted into a value." );
throw ExceptionType("The string \"", ai_str_toprintable(in, 30), "\" cannot be converted into a value." );
}
for ( ;; ) {
@ -293,7 +294,7 @@ const char* fast_atoreal_move(const char* c, Real& out, bool check_comma = true)
if (!(c[0] >= '0' && c[0] <= '9') &&
!((c[0] == '.' || (check_comma && c[0] == ',')) && c[1] >= '0' && c[1] <= '9')) {
// The string is known to be bad, so don't risk printing the whole thing.
throw ExceptionType("Cannot parse string \"", std::string(c).substr(0, 100),
throw ExceptionType("Cannot parse string \"", ai_str_toprintable(c, 30),
"\" as a real number: does not start with digit "
"or decimal point followed by digit.");
}