/** * @class ProtoDebug * * @brief Debugging routines * * PROTOLIB DEBUG LEVELS: * * @li PL_FATAL=0 // The FATAL level designates very severe error events that will presumably lead the application to abort. * @li PL_ERROR=1; // The ERROR level designates error events that might still allow the application to continue running. * @li PL_WARN=2; // The WARN level designates potentially harmful situations. * @li PL_INFO=3; // The INFO level designates informational messages that highlight the progress of the application at coarse-grained level. * @li PL_DEBUG=4; // The DEBUG level designates fine-grained informational events that are most useful to debug an application. * @li PL_TRACE=5; // The TRACE level designates finer-grained informational events than the DEBUG * @li PL_DETAIL=6; // The TRACE level designates even finer-grained informational events than the DEBUG * @li PL_MAX=7; // Turn all comments on * @li PL_ALWAYS // Messages at this level are always printed regardless of debug level */ #ifndef _PROTO_DEBUG #define _PROTO_DEBUG #include "protoDefs.h" #ifdef WIN32 #include #else #include // for strerror() #include // for errno #endif // if/else WIN32/UNIX enum ProtoDebugLevel {PL_FATAL, PL_ERROR, PL_WARN, PL_INFO, PL_DEBUG, PL_TRACE, PL_DETAIL, PL_MAX, PL_ALWAYS}; #if defined(PROTO_DEBUG) || defined(PROTO_MSG) void SetDebugLevel(unsigned int level); unsigned int GetDebugLevel(); bool OpenDebugLog(const char *path); // log debug messages to the file named "path" void CloseDebugLog(); bool OpenDebugPipe(const char* pipeName); // log debug messages to a datagram ProtoPipe (PLOG only) void CloseDebugPipe(); void ProtoDMSG(unsigned int level, const char *format, ...); void ProtoLog(ProtoDebugLevel level, const char *format, ...); FILE* GetDebugLog(); #ifdef WIN32 void OpenDebugWindow(); void PopupDebugWindow(); void CloseDebugWindow(); #endif // WIN32 #else inline void SetDebugLevel(unsigned int level) {} inline unsigned int GetDebugLevel() {return PL_FATAL;} inline bool OpenDebugLog(const char *path) {return true;} inline void CloseDebugLog() {} inline bool OpenDebugPipe(const char* pipeName) {return true;} inline void CloseDebugPipe() {} inline void ProtoDMSG(unsigned int level, const char *format, ...) {} inline void ProtoLog(ProtoDebugLevel level, const char *format, ...) {} #ifdef WIN32 inline void OpenDebugWindow() {} inline void PopupDebugWindow() {} inline void CloseDebugWindow() {} #endif // WIN32 #endif // if/else PROTO_DEBUG || PROTO_MSG // printf()-like debug logging routines (Note DMSG() is deprecated) // Call the PLOG() macro for better performance inline void ProtoNoop() {} #define PLOG(X, ...) ((((unsigned int)X <= ::GetDebugLevel()) || (X == PL_ALWAYS)) ? \ ProtoLog(X, ##__VA_ARGS__) : ProtoNoop()) #define DMSG(X, ...) ((unsigned int)X <= ::GetDebugLevel() ? ProtoDMSG(X, ##__VA_ARGS__) : ProtoNoop()) #if defined(PROTO_DEBUG) || defined(PROTO_MSG) // The following prototype and "SetAssertFunction()" allows the behavior of the PROTO_ASSERT macro // to be overridden. The default behavior is just a call to the "assert()" system call (or ABORT() if no "assert()" call is available) // IMPORTANT NOTE: The "NDEBUG" macro can be enabled to disable the "assert()" system call even // if the "PROTO_DEBUG" is kept in place. typedef void (ProtoAssertFunction)(bool condition, const char* conditionText, const char* fileName, int lineNumber, void* userData); void SetAssertFunction(ProtoAssertFunction* assertFunction, void* userData = NULL); void ClearAssertFunction(); bool HasAssertFunction(); void ProtoAssertHandler(bool condition, const char* conditionText, const char* fileName, int lineNumber); void PROTO_ABORT(const char *format, ...); #ifdef HAVE_ASSERT #ifdef __ANDROID__ #include #define PROTO_ASSERT(X) {if (HasAssertFunction()) ProtoAssertHandler(X, #X, __FILE__, __LINE__); \ else if (!((bool)(X))) __android_log_assert(#X, "protolib", "%s line:%d", __FILE__, __LINE__);} #else #include #define PROTO_ASSERT(X) {if (HasAssertFunction()) ProtoAssertHandler(X, #X, __FILE__, __LINE__); else assert(X);} #endif // if/else __ANDROID__ #else #define PROTO_ASSERT(X) \ {if (HasAssertFunction()) ProtoAssertHandler(X, #X, __FILE__, __LINE__); \ else if (!((bool)(X))) PROTO_ABORT("ASSERT(%s) failed at line %d in source file \"%s\"\n", #X, __LINE__, __FILE__);} #endif // if/else HAVE_ASSERT #ifdef TRACE #undef TRACE #endif // TRACE void TRACE(const char *format, ...); #else // !PROTO_DEBUG #define PROTO_ASSERT(X) #ifndef ABORT #define ABORT(X) #endif // !ABORT #ifndef TRACE inline void TRACE(const char *format, ...) {} #endif // !TRACE #endif // if/else PROTO_DEBUG // Historically, "protolib" has used an "ASSERT()" macro for assertions. It now makes sense to // transition to a more explicit "PROTO_ASSERT()" - we should/will probably deprecate this // "ASSERT()" macro definition but for now it is in many projects that use Protolib #undef ASSERT #define ASSERT(X) PROTO_ASSERT(X) inline const char* GetErrorString() { #ifdef WIN32 static char errorString[256]; errorString[255] = '\0'; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) errorString, 255, NULL); return errorString; #else return strerror(errno); #endif // if/else WIN32/UNIX } #ifdef WIN32 typedef DWORD ProtoErrorCode; #else typedef int ProtoErrorCode; #endif // if/else WIN32/UNIX inline const char* GetErrorString(ProtoErrorCode errorCode) { #ifdef WIN32 static char errorString[256]; errorString[255] = '\0'; FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language (LPTSTR) errorString, 255, NULL); return errorString; #else return strerror(errorCode); #endif // if/else WIN32/UNIX } #endif // _PROTO_DEBUG