- Generated on Fri Feb 8 2013 08:41:05 for ML Reference by
1.7.4
|
ML Reference
|
00001 // **InsertLicense** code 00002 //---------------------------------------------------------------------------------- 00005 00010 //---------------------------------------------------------------------------------- 00011 00012 #ifndef __mlErrorMacros_H 00013 #define __mlErrorMacros_H 00014 00015 #include "mlMacros.h" 00016 00017 // ------------------------------------------------------ 00018 // Disabling some bogus warnings in MeVis release mode 00019 // ------------------------------------------------------ 00020 #if defined(_MSC_VER) 00021 #pragma warning(push) 00022 #if !defined(_DEBUG) 00023 #pragma warning(disable: 4701) // local variable *may* be used without init 00024 #pragma warning(disable: 4702) // unreachable code 00025 #pragma warning(disable: 4710) // private constructors are disallowed 00026 #pragma warning(disable: 4097) // typedef-name 'identifier1' used as synonym for class-name 'identifier2' 00027 #pragma warning(disable: 4512) // 'class' : assignment operator could not be generated 00028 #pragma warning(disable: 4127) // conditional expression is constant 00029 #pragma warning(disable: 4711) // selected for automatic inline expansion 00030 #endif 00031 #pragma warning(disable: 4127) // conditional expression is constant 00032 #endif 00033 00034 #include "mlLogging.h" 00035 00036 #if defined(_MSC_VER) 00037 #pragma warning(pop) 00038 #endif 00039 //---------------------------------------------------------------------------------- 00040 // 00041 // MeVis implementation of error and tracing macros. 00042 // 00043 //---------------------------------------------------------------------------------- 00044 00047 #ifdef _DEBUG 00048 #ifdef ML_COMPILE_DEBUG_EXCEPTION_HANDLING 00049 #undef ML_SUPPRESS_DIAGNOSIS 00050 #endif 00051 #endif 00052 00053 00054 #ifndef ML_SUPPRESS_DIAGNOSIS 00055 00056 #ifdef _DEBUG 00057 #ifndef ML_COMPILE_DEBUG_EXCEPTION_HANDLING 00058 00059 00060 #define ML_SUPPRESS_DIAGNOSIS 00061 #endif 00062 00063 #else // _DEBUG 00064 00065 // In release mode the try/catch mechanisms are compiled such that 00066 // maximum stability of the application and logging is reached. 00067 // #define ML_SUPPRESS_DIAGNOSIS 00068 00069 #endif // _DEBUG 00070 00071 #endif // ifndef ML_SUPPRESS_DIAGNOSIS 00072 00073 00074 00075 //--------------------------------------------------------------------------- 00076 // Compile diagnosis and error checking macros if ML_SUPPRESS_DIAGNOSIS is 00077 // not defined. Then tracing and try/catching of errors is activated. 00078 // However exact debugging of error positions not possible any more. 00079 //--------------------------------------------------------------------------- 00080 #ifndef ML_SUPPRESS_DIAGNOSIS 00081 00082 //----------------------------------------------------------------- 00083 /* This area is used for the mode comparable to the release mode */ 00084 //----------------------------------------------------------------- 00085 00086 //--------------------------------------------------------------------------- 00088 00089 //--------------------------------------------------------------------------- 00090 #define ML_TRACE_IN(__classAndMethod___) static const char * const __ML_TRACE_IN_STRING_BUF = __FILE__ ":" __classAndMethod___; \ 00091 ml::Trace<MLuint16> __MLTraceObject(__ML_TRACE_IN_STRING_BUF, ml::MLGlobalTraceBuffer); 00092 00093 // Specialized tracing macro for time critical code. Usually only compiled for diagnostics versions. 00094 #ifdef ML_COMPILE_ML_TRACE_IN_TIME_CRITICAL 00095 // Compile even ML_TRACE_IN_TIME_CRITICAL if explicitly enabled. 00096 #define ML_TRACE_IN_TIME_CRITICAL(__classAndMethod___) ML_TRACE_IN(__classAndMethod___) 00097 #else 00098 // Normally do not compile ML_TRACE_IN_TIME_CRITICAL since it's time critical. 00099 #define ML_TRACE_IN_TIME_CRITICAL(__classAndMethod___) 00100 #endif 00101 00102 #ifdef ML_DEPRECATED 00103 00104 00105 00106 00107 #define ML_TRACE_IN_TC(__classAndMethod___) ML_TRACE_IN_TIME_CRITICAL(__classAndMethod___) 00108 00109 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00110 #pragma deprecated("ML_TRACE_IN_TC") 00111 #endif 00112 00113 #endif // ML_DEPRECATED 00114 00115 // Specialized tracing macro for diagnostic function inside of the ML. These function 00116 // are considered reliable and are only traced if explicitly enabled with definition 00117 // ML_COMPILE_ML_INTERNAL_ERROR_TRACE_IN. In normal case they are not traced to avoid 00118 // that normal error handling functions inside the ML are also traced. 00119 // Enabled usually only in diagnostic versions. 00120 #ifdef ML_COMPILE_ML_INTERNAL_ERROR_TRACE_IN 00121 00122 #define ML_INTERNAL_ERROR_TRACE_IN(__classAndMethod___) ML_TRACE_IN(__classAndMethod___) 00123 #else 00124 // Normally do not compile ML_TRACE_IN_TIME_CRITICAL since it's time critical. 00125 #define ML_INTERNAL_ERROR_TRACE_IN(__classAndMethod___) 00126 #endif 00127 00128 00129 00130 //---------------------------------------- 00132 00133 //---------------------------------------- 00134 #define ML_TRY try 00135 00136 #define ML_CATCH catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); } 00137 #define ML_CATCH_RETURN catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); return; } 00138 #define ML_CATCH_RETURN_FALSE catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); return false; } 00139 #define ML_CATCH_RETURN_NULL catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); return 0; } 00140 #define ML_CATCH_RETHROW catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_UNKNOWN_EXCEPTION); throw; } 00141 #define ML_CATCH_BLOCK(__paramType) catch(__paramType) 00142 00143 #ifdef ML_DEPRECATED 00144 00145 00146 00147 00148 #define ML_CATCH_R ML_CATCH_RETURN 00149 00150 00151 #define ML_CATCH_RF ML_CATCH_RETURN_FALSE 00152 00153 00154 #define ML_CATCH_RN ML_CATCH_RETURN_NULL 00155 00156 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00157 #pragma deprecated("ML_CATCH_R", "ML_CATCH_RF", "ML_CATCH_RN") 00158 #endif 00159 00160 00161 #endif // ML_DEPRECATED 00162 00163 00164 00165 //---------------------------------------- 00167 00168 //---------------------------------------- 00169 #define ML_CHECK(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); } 00170 #define ML_CHECK_ONLY_IN_DEBUG(x) /* Behaves like assert, not compiled in release mode */ 00171 #define ML_CHECK_RETURN(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return; } 00172 #define ML_CHECK_RETURN_FALSE(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return false; } 00173 #define ML_CHECK_RETURN_NULL(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return 0; } 00174 #define ML_CHECK_THROW(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); throw ML_BAD_POINTER_OR_0; } 00175 #define ML_CHECK_RUNTIME_TYPE(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_TYPE_NOT_REGISTERED); throw ML_TYPE_NOT_REGISTERED; } 00176 00177 #ifdef ML_DEPRECATED 00178 00179 00180 00181 00182 #define ML_CHECK_R(x) ML_CHECK_RETURN(x) 00183 00184 00185 #define ML_CHECK_RF(x) ML_CHECK_RETURN_FALSE(x) 00186 00187 00188 #define ML_CHECK_RN(x) ML_CHECK_RETURN_NULL(x) 00189 00190 00191 #define ML_CHECK_TH(x) ML_CHECK_THROW(x) 00192 00193 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00194 #pragma deprecated("ML_CHECK_R", "ML_CHECK_RF", "ML_CHECK_RN", "ML_CHECK_TH") 00195 #endif 00196 00197 #endif // ML_DEPRECATED 00198 00199 00200 00201 //---------------------------------------- 00203 00204 //---------------------------------------- 00205 #define ML_CHECK_FLOAT(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); } 00206 #define ML_CHECK_FLOAT_RETURN(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return; } 00207 #define ML_CHECK_FLOAT_RETURN_FALSE(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return false; } 00208 #define ML_CHECK_FLOAT_RETURN_NULL(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return 0; } 00209 #define ML_CHECK_FLOAT_THROW(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); throw ML_BAD_POINTER_OR_0; } 00210 #define ML_CHECK_FLOAT_RUNTIME_TYPE(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_TYPE_NOT_REGISTERED); throw ML_TYPE_NOT_REGISTERED; } 00211 00212 #ifdef ML_DEPRECATED 00213 00214 00215 00216 00217 #define ML_CHECK_FLT_R(x) ML_CHECK_FLOAT_RETURN(x) 00218 00219 00220 #define ML_CHECK_FLT_RF(x) ML_CHECK_FLOAT_RETURN_FALSE(x) 00221 00222 00223 #define ML_CHECK_FLT_RN(x) ML_CHECK_FLOAT_RETURN_NULL(x) 00224 00225 00226 #define ML_CHECK_FLT_TH(x) ML_CHECK_FLOAT_THROW(x) 00227 00228 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00229 #pragma deprecated("ML_CHECK_FLT_R", "ML_CHECK_FLT_RF", "ML_CHECK_FLT_RN", "ML_CHECK_FLT_TH") 00230 #endif 00231 00232 #endif // ML_DEPRECATED 00233 00234 00235 00236 //---------------------------------------- 00238 00239 //---------------------------------------- 00240 #define ML_CHECK_NEW(var, exp) try{ (var) = new exp; if (NULL == (var)){ throw(ML_NO_MEMORY); } } catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, (NULL == (var)) ? ML_NO_MEMORY : ML_CONSTRUCTOR_EXCEPTION); } 00241 #define ML_CHECK_NEW_TH(var, exp) try{ (var) = new exp; if (NULL == (var)){ throw(ML_NO_MEMORY); } } catch(...){ MLPrintAndNotifyFatal(__FILE__, __LINE__, (NULL == (var)) ? ML_NO_MEMORY : ML_CONSTRUCTOR_EXCEPTION); throw; } 00242 #define ML_DELETE(var) if (0 !=(var)){ delete (var); (var) = 0; } 00243 #define ML_DELETE_ARRAY(var) if (0 !=(var)){ delete[](var); (var) = 0; } 00244 00245 #ifdef ML_DEPRECATED 00246 00247 00248 00249 00250 #define ML_DELETE_ARR(var) ML_DELETE_ARRAY(var) 00251 00252 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00253 #pragma deprecated("ML_DELETE_ARR") 00254 #endif 00255 00256 #endif // ML_DEPRECATED 00257 00258 00259 #else // of "ifndef ML_SUPPRESS_DIAGNOSIS" 00260 00261 //--------------------------------------------------------------- 00262 /* This area is used for the mode comparable to the debug mode */ 00263 //--------------------------------------------------------------- 00264 00265 //---------------------------------------- 00267 00268 //---------------------------------------- 00269 #if 1 00270 // Here we are in the normal "debug" mode. We do not compile any exception handlers nor tracing 00271 // here. Thus we disable also the tracing macro, because tracing is used typically only in release 00272 // mode where the application continues, crashes are suppressed as far as possible and diagnosis is 00273 // only possible with tracing information in log files. 00274 // In debug mode we let everything crash and tracing is not needed, because we have all information 00275 // available in debugger call stacks etc. For internal developer purposes it also could be enabled 00276 // here. 00277 #define ML_TRACE_IN(__classAndMethod___) 00278 #else 00279 #define ML_TRACE_IN(__classAndMethod___) static const char * const __ML_TRACE_IN_STRING_BUF = __FILE__ ":" __classAndMethod___; \ 00280 ml::Trace<MLuint16> __MLTraceObject(__ML_TRACE_IN_STRING_BUF, ml::MLGlobalTraceBuffer); 00281 #endif 00282 00283 00284 #ifdef ML_COMPILE_ML_TRACE_IN_TIME_CRITICAL 00285 // Compile even ML_TRACE_IN_TIME_CRITICAL if explicitly enabled. 00286 #define ML_TRACE_IN_TIME_CRITICAL(__classAndMethod___) ML_TRACE_IN(__classAndMethod___) 00287 #else 00288 // Normally do not compile ML_TRACE_IN_TIME_CRITICAL since it's time critical. 00289 #define ML_TRACE_IN_TIME_CRITICAL(__classAndMethod___) 00290 #endif 00291 00292 #ifdef ML_DEPRECATED 00293 00294 00295 00296 00297 #define ML_TRACE_IN_TC(__classAndMethod___) ML_TRACE_IN_TIME_CRITICAL(__classAndMethod___) 00298 00299 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00300 #pragma deprecated("ML_TRACE_IN_TC") 00301 #endif 00302 00303 #endif // ML_DEPRECATED 00304 00305 // Specialized tracing macro for diagnostic function inside of the ML. These function 00306 // are considered reliable and are only traced if explicitly enabled with definition 00307 // ML_COMPILE_ML_INTERNAL_ERROR_TRACE_IN. In normal case they are not traced to avoid that normal 00308 // error handling functions inside the ML are also traced. 00309 // Enabled usually only in diagnostic versions. 00310 #ifdef ML_COMPILE_ML_INTERNAL_ERROR_TRACE_IN 00311 // Compile ML_INTERNAL_ERROR_TRACE_IN only if explicitly enabled. 00312 #define ML_INTERNAL_ERROR_TRACE_IN(__classAndMethod___) ML_TRACE_IN(__classAndMethod___) 00313 #else 00314 // Normally do not compile ML_INTERNAL_ERROR_TRACE_IN since it's disturbs normal tracing outputs. 00315 #define ML_INTERNAL_ERROR_TRACE_IN(__classAndMethod___) 00316 #endif 00317 00318 00319 00320 //---------------------------------------- 00322 00323 //---------------------------------------- 00324 #define ML_TRY 00325 00326 #define ML_CATCH 00327 #define ML_CATCH_RETURN 00328 #define ML_CATCH_RETURN_FALSE 00329 #define ML_CATCH_RETURN_NULL 00330 #define ML_CATCH_RETHROW 00331 #define ML_CATCH_BLOCK(__paramType) if (MLAlwaysFalse) 00332 00333 #ifdef ML_DEPRECATED 00334 00335 00336 00337 00338 #define ML_CATCH_R ML_CATCH_RETURN 00339 00340 00341 #define ML_CATCH_RF ML_CATCH_RETURN_FALSE 00342 00343 00344 #define ML_CATCH_RN ML_CATCH_RETURN_NULL 00345 00346 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00347 #pragma deprecated("ML_CATCH_R", "ML_CATCH_RF", "ML_CATCH_RN") 00348 #endif 00349 00350 #endif // ML_DEPRECATED 00351 00352 00353 //---------------------------------------------------------------------------------------- 00355 00356 //---------------------------------------------------------------------------------------- 00357 #define ML_CHECK(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0);}; 00358 #define ML_CHECK_ONLY_IN_DEBUG(x) ML_CHECK(x) 00359 #define ML_CHECK_RETURN(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return;} 00360 #define ML_CHECK_RETURN_FALSE(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return false;} 00361 #define ML_CHECK_RETURN_NULL(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return 0;} 00362 #define ML_CHECK_THROW(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); throw ML_BAD_POINTER_OR_0;} 00363 #define ML_CHECK_RUNTIME_TYPE(x) if (!(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_TYPE_NOT_REGISTERED); throw ML_TYPE_NOT_REGISTERED;} 00364 00365 #ifdef ML_DEPRECATED 00366 00367 00368 00369 00370 #define ML_CHECK_R(x) ML_CHECK_RETURN(x) 00371 00372 00373 #define ML_CHECK_RF(x) ML_CHECK_RETURN_FALSE(x) 00374 00375 00376 #define ML_CHECK_RN(x) ML_CHECK_RETURN_NULL(x) 00377 00378 00379 #define ML_CHECK_TH(x) ML_CHECK_THROW(x) 00380 00381 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00382 #pragma deprecated("ML_CHECK_R", "ML_CHECK_RF", "ML_CHECK_RN", "ML_CHECK_TH") 00383 #endif 00384 00385 #endif // ML_DEPRECATED 00386 00388 00389 //---------------------------------------- 00391 00392 //---------------------------------------- 00393 #define ML_CHECK_FLOAT(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); } 00394 #define ML_CHECK_FLOAT_RETURN(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return; } 00395 #define ML_CHECK_FLOAT_RETURN_FALSE(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return false; } 00396 #define ML_CHECK_FLOAT_RETURN_NULL(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); return 0; } 00397 #define ML_CHECK_FLOAT_THROW(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_BAD_POINTER_OR_0); throw ML_BAD_POINTER_OR_0; } 00398 #define ML_CHECK_FLOAT_RUNTIME_TYPE(x) if (MLValueIs0WOM(x)){ MLPrintAndNotifyFatal(__FILE__, __LINE__, ML_TYPE_NOT_REGISTERED); throw ML_TYPE_NOT_REGISTERED; } 00399 00400 #ifdef ML_DEPRECATED 00401 00402 00403 00404 00405 #define ML_CHECK_FLT_R(x) ML_CHECK_FLT_RETURN(x) 00406 00407 00408 #define ML_CHECK_FLT_RF(x) ML_CHECK_FLT_RETURN_FALSE(x) 00409 00410 00411 #define ML_CHECK_FLT_RN(x) ML_CHECK_FLT_RETURN_NULL(x) 00412 00413 00414 #define ML_CHECK_FLT_TH(x) ML_CHECK_FLT_THROW(x) 00415 00416 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00417 #pragma deprecated("ML_CHECK_FLT_R", "ML_CHECK_FLT_RF", "ML_CHECK_FLT_RN", "ML_CHECK_FLT_TH") 00418 #endif 00419 00420 #endif // ML_DEPRECATED 00421 00422 00423 00424 //---------------------------------------- 00426 00427 //---------------------------------------- 00428 #define ML_CHECK_NEW(var, exp) (var) = new exp; 00429 #define ML_CHECK_NEW_TH(var, exp) (var) = new exp; 00430 #define ML_DELETE(var) if (0 !=(var)){ delete (var); (var) = 0; } 00431 #define ML_DELETE_ARRAY(var) if (0 !=(var)){ delete[](var); (var) = 0; } 00432 00433 #ifdef ML_DEPRECATED 00434 00435 00436 00437 00438 #define ML_DELETE_ARR(var) ML_DELETE_ARRAY(var) 00439 00440 #if defined(WIN32) && defined(ML_WARN_DEPRECATED) 00441 #pragma deprecated("ML_DELETE_ARR") 00442 #endif 00443 00444 #endif // ML_DEPRECATED 00445 00446 00447 00448 #endif // ifdef ML_SUPPRESS_DIAGNOSIS 00449 00450 00451 //----------------------------------------------------------------------------------------------- 00453 00454 //----------------------------------------------------------------------------------------------- 00459 #define _ML_INFORMATION_ADD_ON(FUNC_NAME, REASON, HANDLING) 00460 00465 #define _ML_WARNING_ADD_ON(FUNC_NAME, REASON, HANDLING) 00466 00471 #define _ML_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING) 00472 00477 #define _ML_FATAL_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING) 00478 00484 #define _ML_ERROR_SHOW_ASSERT_BOX(PARAM) 00485 00486 00487 00488 00489 00490 00491 //-------------------------------------------------------------------------------------------- 00492 // 00494 00495 // 00496 //-------------------------------------------------------------------------------------------- 00497 00498 //-------------------------------------------------------------------------------------------- 00511 //-------------------------------------------------------------------------------------------- 00512 #define _ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE) \ 00513 { \ 00514 /* Get runtime information from RTYPE which could be a crashing expression.*/ \ 00515 const ML_UTILS_NAMESPACE::RuntimeType *rtt7645 = NULL; \ 00516 try{ rtt7645 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rtt7645 = NULL; }\ 00517 _ML_FATAL_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING) \ 00518 ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_FATAL, \ 00519 ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \ 00520 __FILE__, __LINE__, RT_OBJ, rtt7645); \ 00521 _ML_ERROR_SHOW_ASSERT_BOX(0); \ 00522 } 00523 00524 //-------------------------------------------------------------------------------------------- 00537 //-------------------------------------------------------------------------------------------- 00538 #define _ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE) \ 00539 { \ 00540 /* Get runtime information from RTYPE which could be a crashing expression.*/ \ 00541 const ML_UTILS_NAMESPACE::RuntimeType *rtt1987 = NULL; \ 00542 try{ rtt1987 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rtt1987 = NULL; }\ 00543 _ML_ERROR_ADD_ON(FUNC_NAME, REASON, HANDLING) \ 00544 ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_ERROR, \ 00545 ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \ 00546 __FILE__, __LINE__, RT_OBJ, rtt1987); \ 00547 _ML_ERROR_SHOW_ASSERT_BOX(0); \ 00548 } 00549 00550 //-------------------------------------------------------------------------------------------- 00564 //-------------------------------------------------------------------------------------------- 00565 #define _ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE) \ 00566 { \ 00567 /* Get runtime information from RTYPE which could be a crashing expression.*/ \ 00568 const ML_UTILS_NAMESPACE::RuntimeType *rt9477 = NULL; \ 00569 try{ rt9477 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rt9477 = NULL; } \ 00570 _ML_WARNING_ADD_ON(FUNC_NAME, REASON, HANDLING) \ 00571 ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_WARNING, \ 00572 ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \ 00573 __FILE__, __LINE__, RT_OBJ, rt9477); \ 00574 /* No showing of assert box here. That would be to drastic. */ \ 00575 } 00576 00577 //-------------------------------------------------------------------------------------------- 00591 //-------------------------------------------------------------------------------------------- 00592 #define _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, RTYPE) \ 00593 { \ 00594 /* Get runtime information from RTYPE which could be a crashing expression.*/ \ 00595 const ML_UTILS_NAMESPACE::RuntimeType *rtAx598 = NULL; \ 00596 try{ rtAx598 = RTYPE; if (MLAlwaysFalse){ throw ML_UNKNOWN_EXCEPTION;} } catch(...){ rtAx598 = NULL; }\ 00597 _ML_INFORMATION_ADD_ON(FUNC_NAME, REASON, HANDLING) \ 00598 ML_UTILS_NAMESPACE::MLErrorOutput.printAndNotify(ML_INFORMATION, \ 00599 ML_PREFIX, "Function=", FUNC_NAME, REASON, HANDLING, \ 00600 __FILE__, __LINE__, RT_OBJ, rtAx598); \ 00601 /* No showing of assert box here. That would be to drastic. */ \ 00602 } 00603 00604 00605 00606 00607 //-------------------------------------------------------------------------------------------- 00608 // 00610 00611 // 00612 //-------------------------------------------------------------------------------------------- 00613 //-------------------------------------------------------------------------------------------- 00616 //-------------------------------------------------------------------------------------------- 00617 #define ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \ 00618 /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \ 00619 _ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : NULL)) 00620 00621 //-------------------------------------------------------------------------------------------- 00624 //-------------------------------------------------------------------------------------------- 00625 #define ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \ 00626 /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \ 00627 _ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : NULL)) 00628 00629 //-------------------------------------------------------------------------------------------- 00632 //-------------------------------------------------------------------------------------------- 00633 #define ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \ 00634 /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \ 00635 _ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : NULL)) 00636 00637 //-------------------------------------------------------------------------------------------- 00640 //-------------------------------------------------------------------------------------------- 00641 #define ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ) \ 00642 /* Use OR with MLAlwaysFalse to avoid compiler warnings about unreachable code when constant RT_OBJ is passed from other macro. */ \ 00643 _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, RT_OBJ, (((RT_OBJ) || MLAlwaysFalse) ? (RT_OBJ)->getTypeId() : NULL)) 00644 00646 00647 00648 00649 //-------------------------------------------------------------------------------------------- 00650 // 00652 00653 // 00654 //-------------------------------------------------------------------------------------------- 00655 00656 //-------------------------------------------------------------------------------------------- 00661 //-------------------------------------------------------------------------------------------- 00662 #define ML_PRINT_FATAL_ERROR(FUNC_NAME, REASON, HANDLING) \ 00663 _ML_PRINT_FATAL_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, NULL, NULL) 00664 00665 //-------------------------------------------------------------------------------------------- 00670 //-------------------------------------------------------------------------------------------- 00671 #define ML_PRINT_ERROR(FUNC_NAME, REASON, HANDLING) \ 00672 _ML_PRINT_ERROR_DUMP(FUNC_NAME, REASON, HANDLING, NULL, NULL) 00673 00674 //-------------------------------------------------------------------------------------------- 00679 //-------------------------------------------------------------------------------------------- 00680 #define ML_PRINT_WARNING(FUNC_NAME, REASON, HANDLING) \ 00681 _ML_PRINT_WARNING_DUMP(FUNC_NAME, REASON, HANDLING, NULL, NULL) 00682 00683 //-------------------------------------------------------------------------------------------- 00688 //-------------------------------------------------------------------------------------------- 00689 #define ML_PRINT_INFORMATION(FUNC_NAME, REASON, HANDLING) \ 00690 _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, REASON, HANDLING, NULL, NULL) 00691 00692 //-------------------------------------------------------------------------------------------- 00696 //-------------------------------------------------------------------------------------------- 00697 #define ML_PRINT_INFO(FUNC_NAME, HANDLING) \ 00698 _ML_PRINT_INFORMATION_DUMP(FUNC_NAME, ML_RESULT_OK, HANDLING, NULL, NULL) 00699 00701 00702 00703 00704 00705 #endif // __mlErrorMacros_H 00706 00707
1.7.4