log4cplus  1.1.0
loggingmacros.h
Go to the documentation of this file.
00001 // -*- C++ -*-
00002 // Module:  Log4CPLUS
00003 // File:    loggingmacros.h
00004 // Created: 8/2003
00005 // Author:  Tad E. Smith
00006 //
00007 //
00008 // Copyright 2003-2010 Tad E. Smith
00009 //
00010 // Licensed under the Apache License, Version 2.0 (the "License");
00011 // you may not use this file except in compliance with the License.
00012 // You may obtain a copy of the License at
00013 //
00014 //     http://www.apache.org/licenses/LICENSE-2.0
00015 //
00016 // Unless required by applicable law or agreed to in writing, software
00017 // distributed under the License is distributed on an "AS IS" BASIS,
00018 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00019 // See the License for the specific language governing permissions and
00020 // limitations under the License.
00021 
00025 #ifndef LOG4CPLUS_LOGGING_MACROS_HEADER_
00026 #define LOG4CPLUS_LOGGING_MACROS_HEADER_
00027 
00028 #include <log4cplus/config.hxx>
00029 
00030 #if defined (LOG4CPLUS_HAVE_PRAGMA_ONCE)
00031 #pragma once
00032 #endif
00033 
00034 #include <log4cplus/streams.h>
00035 #include <log4cplus/logger.h>
00036 #include <log4cplus/helpers/snprintf.h>
00037 #include <log4cplus/tracelogger.h>
00038 #include <sstream>
00039 #include <utility>
00040 
00041 
00042 #if defined(_MSC_VER)
00043 #define LOG4CPLUS_SUPPRESS_DOWHILE_WARNING()  \
00044     __pragma (warning (push))                 \
00045     __pragma (warning (disable:4127))           
00046 
00047 #define LOG4CPLUS_RESTORE_DOWHILE_WARNING()   \
00048     __pragma (warning (pop))
00049 
00050 #else
00051 #define LOG4CPLUS_SUPPRESS_DOWHILE_WARNING() /* empty */
00052 #define LOG4CPLUS_RESTORE_DOWHILE_WARNING() /* empty */
00053 
00054 #endif
00055 
00056 #define LOG4CPLUS_DOWHILE_NOTHING()                 \
00057     LOG4CPLUS_SUPPRESS_DOWHILE_WARNING()            \
00058     do { } while (0)                                \
00059     LOG4CPLUS_RESTORE_DOWHILE_WARNING()
00060 
00061 #if defined(LOG4CPLUS_DISABLE_FATAL) && !defined(LOG4CPLUS_DISABLE_ERROR)
00062 #define LOG4CPLUS_DISABLE_ERROR
00063 #endif
00064 #if defined(LOG4CPLUS_DISABLE_ERROR) && !defined(LOG4CPLUS_DISABLE_WARN)
00065 #define LOG4CPLUS_DISABLE_WARN
00066 #endif
00067 #if defined(LOG4CPLUS_DISABLE_WARN) && !defined(LOG4CPLUS_DISABLE_INFO)
00068 #define LOG4CPLUS_DISABLE_INFO
00069 #endif
00070 #if defined(LOG4CPLUS_DISABLE_INFO) && !defined(LOG4CPLUS_DISABLE_DEBUG)
00071 #define LOG4CPLUS_DISABLE_DEBUG
00072 #endif
00073 #if defined(LOG4CPLUS_DISABLE_DEBUG) && !defined(LOG4CPLUS_DISABLE_TRACE)
00074 #define LOG4CPLUS_DISABLE_TRACE
00075 #endif
00076 
00077 
00078 namespace log4cplus
00079 {
00080 
00081 namespace detail
00082 {
00083 
00084 
00085 inline
00086 Logger
00087 macros_get_logger (Logger const & logger)
00088 {
00089     return logger;
00090 }
00091 
00092 
00093 inline
00094 Logger const &
00095 macros_get_logger (Logger & logger)
00096 {
00097     return logger;
00098 }
00099 
00100 
00101 #if defined (LOG4CPLUS_HAVE_RVALUE_REFS)
00102 inline
00103 Logger
00104 macros_get_logger (Logger && logger)
00105 {
00106     return std::move (logger);
00107 }
00108 
00109 #endif
00110 
00111 
00112 inline
00113 Logger
00114 macros_get_logger (tstring const & logger)
00115 {
00116     return Logger::getInstance (logger);
00117 }
00118 
00119 
00120 inline
00121 Logger
00122 macros_get_logger (tchar const * logger)
00123 {
00124     return Logger::getInstance (logger);
00125 }
00126 
00127 
00128 LOG4CPLUS_EXPORT void clear_tostringstream (tostringstream &);
00129 
00130 
00131 LOG4CPLUS_EXPORT log4cplus::tostringstream & get_macro_body_oss ();
00132 LOG4CPLUS_EXPORT log4cplus::helpers::snprintf_buf & get_macro_body_snprintf_buf ();
00133 LOG4CPLUS_EXPORT void macro_forced_log (log4cplus::Logger const &,
00134     log4cplus::LogLevel, log4cplus::tstring const &, char const *, int,
00135     char const *);
00136 
00137 
00138 } // namespace detail
00139 
00140 } // namespace log4cplus
00141 
00142 
00143 #undef LOG4CPLUS_MACRO_FUNCTION
00144 #define LOG4CPLUS_MACRO_FUNCTION() 0
00145 #if ! defined (LOG4CPLUS_DISABLE_FUNCTION_MACRO)
00146 #  if defined (LOG4CPLUS_HAVE_FUNCSIG_MACRO)
00147 #    undef LOG4CPLUS_MACRO_FUNCTION
00148 #    define LOG4CPLUS_MACRO_FUNCTION() __FUNCSIG__
00149 #  elif defined (LOG4CPLUS_HAVE_PRETTY_FUNCTION_MACRO)
00150 #    undef LOG4CPLUS_MACRO_FUNCTION
00151 #    define LOG4CPLUS_MACRO_FUNCTION() __PRETTY_FUNCTION__
00152 #  elif defined (LOG4CPLUS_HAVE_FUNCTION_MACRO)
00153 #    undef LOG4CPLUS_MACRO_FUNCTION
00154 #    define LOG4CPLUS_MACRO_FUNCTION() __FUNCTION__
00155 #  elif defined (LOG4CPLUS_HAVE_FUNC_SYMBOL)
00156 #    undef LOG4CPLUS_MACRO_FUNCTION
00157 #    define LOG4CPLUS_MACRO_FUNCTION() __func__
00158 #  endif
00159 #endif
00160 
00161 
00162 // Make TRACE and DEBUG log level unlikely and INFO, WARN, ERROR and
00163 // FATAL log level likely.
00164 #define LOG4CPLUS_MACRO_TRACE_LOG_LEVEL(pred) \
00165     LOG4CPLUS_UNLIKELY (pred)
00166 #define LOG4CPLUS_MACRO_DEBUG_LOG_LEVEL(pred) \
00167     LOG4CPLUS_UNLIKELY (pred)
00168 #define LOG4CPLUS_MACRO_INFO_LOG_LEVEL(pred) \
00169     LOG4CPLUS_LIKELY (pred)
00170 #define LOG4CPLUS_MACRO_WARN_LOG_LEVEL(pred) \
00171     LOG4CPLUS_LIKELY (pred)
00172 #define LOG4CPLUS_MACRO_ERROR_LOG_LEVEL(pred) \
00173     LOG4CPLUS_LIKELY (pred)
00174 #define LOG4CPLUS_MACRO_FATAL_LOG_LEVEL(pred) \
00175     LOG4CPLUS_LIKELY (pred)
00176 
00177 
00179 #define LOG4CPLUS_MACRO_LOGLEVEL_PRED(pred, logLevel)    \
00180     LOG4CPLUS_MACRO_ ## logLevel (pred)
00181 
00182 
00183 // Either use temporary instances of ostringstream
00184 // and snprintf_buf, or use thread-local instances.
00185 #if defined (LOG4CPLUS_MACRO_DISABLE_TLS)
00186 #  define LOG4CPLUS_MACRO_INSTANTIATE_OSTRINGSTREAM(var)    \
00187     log4cplus::tostringstream var
00188 
00189 #  define LOG4CPLUS_MACRO_INSTANTIATE_SNPRINTF_BUF(var)     \
00190     log4cplus::helpers::snprintf_buf var
00191 
00192 #else
00193 #  define LOG4CPLUS_MACRO_INSTANTIATE_OSTRINGSTREAM(var)    \
00194     log4cplus::tostringstream & var                         \
00195         = log4cplus::detail::get_macro_body_oss ()
00196 
00197 #  define LOG4CPLUS_MACRO_INSTANTIATE_SNPRINTF_BUF(var)     \
00198     log4cplus::helpers::snprintf_buf & var                  \
00199         = log4cplus::detail::get_macro_body_snprintf_buf ()
00200 
00201 #endif
00202 
00203 
00204 #define LOG4CPLUS_MACRO_BODY(logger, logEvent, logLevel)                \
00205     LOG4CPLUS_SUPPRESS_DOWHILE_WARNING()                                \
00206     do {                                                                \
00207         log4cplus::Logger const & _l                                    \
00208             = log4cplus::detail::macros_get_logger (logger);            \
00209         if (LOG4CPLUS_MACRO_LOGLEVEL_PRED (                             \
00210                 _l.isEnabledFor (log4cplus::logLevel), logLevel)) {     \
00211             LOG4CPLUS_MACRO_INSTANTIATE_OSTRINGSTREAM (_log4cplus_buf); \
00212             _log4cplus_buf << logEvent;                                 \
00213             log4cplus::detail::macro_forced_log (_l,                    \
00214                 log4cplus::logLevel, _log4cplus_buf.str(),              \
00215                 __FILE__, __LINE__, LOG4CPLUS_MACRO_FUNCTION ());       \
00216         }                                                               \
00217     } while (0)                                                         \
00218     LOG4CPLUS_RESTORE_DOWHILE_WARNING()
00219 
00220 
00221 #define LOG4CPLUS_MACRO_STR_BODY(logger, logEvent, logLevel)            \
00222     LOG4CPLUS_SUPPRESS_DOWHILE_WARNING()                                \
00223     do {                                                                \
00224         log4cplus::Logger const & _l                                    \
00225             = log4cplus::detail::macros_get_logger (logger);            \
00226         if (LOG4CPLUS_MACRO_LOGLEVEL_PRED (                             \
00227                 _l.isEnabledFor (log4cplus::logLevel), logLevel)) {     \
00228             log4cplus::detail::macro_forced_log (_l,                    \
00229                 log4cplus::logLevel, logEvent,                          \
00230                 __FILE__, __LINE__, LOG4CPLUS_MACRO_FUNCTION ());       \
00231         }                                                               \
00232     } while(0)                                                          \
00233     LOG4CPLUS_RESTORE_DOWHILE_WARNING()
00234 
00235 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00236 #define LOG4CPLUS_MACRO_FMT_BODY(logger, logLevel, logFmt, ...)         \
00237     LOG4CPLUS_SUPPRESS_DOWHILE_WARNING()                                \
00238     do {                                                                \
00239         log4cplus::Logger const & _l                                    \
00240             = log4cplus::detail::macros_get_logger (logger);            \
00241         if (LOG4CPLUS_MACRO_LOGLEVEL_PRED (                             \
00242                 _l.isEnabledFor (log4cplus::logLevel), logLevel)) {     \
00243             LOG4CPLUS_MACRO_INSTANTIATE_SNPRINTF_BUF (_snpbuf);         \
00244             log4cplus::tchar const * _logEvent                          \
00245                 = _snpbuf.print (logFmt, __VA_ARGS__);                  \
00246             log4cplus::detail::macro_forced_log (_l,                    \
00247                 log4cplus::logLevel, _logEvent,                         \
00248                 __FILE__, __LINE__, LOG4CPLUS_MACRO_FUNCTION ());       \
00249         }                                                               \
00250     } while(0)                                                          \
00251     LOG4CPLUS_RESTORE_DOWHILE_WARNING()
00252 
00253 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00254 #define LOG4CPLUS_MACRO_FMT_BODY(logger, logLevel, logFmt, logArgs...)  \
00255     LOG4CPLUS_SUPPRESS_DOWHILE_WARNING()                                \
00256     do {                                                                \
00257         log4cplus::Logger const & _l                                    \
00258             = log4cplus::detail::macros_get_logger (logger);            \
00259         if (LOG4CPLUS_MACRO_LOGLEVEL_PRED (                             \
00260                 _l.isEnabledFor (log4cplus::logLevel), logLevel)) {     \
00261             LOG4CPLUS_MACRO_INSTANTIATE_SNPRINTF_BUF (_snpbuf);         \
00262             log4cplus::tchar const * _logEvent                          \
00263                 = _snpbuf.print (logFmt, logArgs);                      \
00264             log4cplus::detail::macro_forced_log (_l,                    \
00265                 log4cplus::logLevel, _logEvent,                         \
00266                 __FILE__, __LINE__, LOG4CPLUS_MACRO_FUNCTION ());       \
00267         }                                                               \
00268     } while(0)                                                          \
00269     LOG4CPLUS_RESTORE_DOWHILE_WARNING()
00270 
00271 #endif
00272 
00273 
00280 #if !defined(LOG4CPLUS_DISABLE_TRACE)
00281 #define LOG4CPLUS_TRACE_METHOD(logger, logEvent)                        \
00282     log4cplus::TraceLogger _log4cplus_trace_logger(logger, logEvent,    \
00283                                                    __FILE__, __LINE__);
00284 #define LOG4CPLUS_TRACE(logger, logEvent)                               \
00285     LOG4CPLUS_MACRO_BODY (logger, logEvent, TRACE_LOG_LEVEL)
00286 #define LOG4CPLUS_TRACE_STR(logger, logEvent)                           \
00287     LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, TRACE_LOG_LEVEL)
00288 
00289 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00290 #define LOG4CPLUS_TRACE_FMT(logger, logFmt, ...)                            \
00291     LOG4CPLUS_MACRO_FMT_BODY (logger, TRACE_LOG_LEVEL, logFmt, __VA_ARGS__)
00292 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00293 #define LOG4CPLUS_TRACE_FMT(logger, logFmt, logArgs...)                     \
00294     LOG4CPLUS_MACRO_FMT_BODY(logger, TRACE_LOG_LEVEL, logFmt, logArgs)
00295 #endif
00296 
00297 #else
00298 #define LOG4CPLUS_TRACE_METHOD(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00299 #define LOG4CPLUS_TRACE(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00300 #define LOG4CPLUS_TRACE_STR(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00301 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00302 #define LOG4CPLUS_TRACE_FMT(logger, logFmt, ...) LOG4CPLUS_DOWHILE_NOTHING()
00303 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00304 #define LOG4CPLUS_TRACE_FMT(logger, logFmt, logArgs...) LOG4CPLUS_DOWHILE_NOTHING()
00305 #endif
00306 
00307 #endif
00308 
00314 #if !defined(LOG4CPLUS_DISABLE_DEBUG)
00315 #define LOG4CPLUS_DEBUG(logger, logEvent)                               \
00316     LOG4CPLUS_MACRO_BODY (logger, logEvent, DEBUG_LOG_LEVEL)
00317 #define LOG4CPLUS_DEBUG_STR(logger, logEvent)                           \
00318     LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, DEBUG_LOG_LEVEL)
00319 
00320 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00321 #define LOG4CPLUS_DEBUG_FMT(logger, logFmt, ...)                            \
00322     LOG4CPLUS_MACRO_FMT_BODY (logger, DEBUG_LOG_LEVEL, logFmt, __VA_ARGS__)
00323 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00324 #define LOG4CPLUS_DEBUG_FMT(logger, logFmt, logArgs...)                     \
00325     LOG4CPLUS_MACRO_FMT_BODY(logger, DEBUG_LOG_LEVEL, logFmt, logArgs)
00326 #endif
00327 
00328 #else
00329 #define LOG4CPLUS_DEBUG(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00330 #define LOG4CPLUS_DEBUG_STR(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00331 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00332 #define LOG4CPLUS_DEBUG_FMT(logger, logFmt, ...) LOG4CPLUS_DOWHILE_NOTHING()
00333 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00334 #define LOG4CPLUS_DEBUG_FMT(logger, logFmt, logArgs...) LOG4CPLUS_DOWHILE_NOTHING()
00335 #endif
00336 
00337 #endif
00338 
00344 #if !defined(LOG4CPLUS_DISABLE_INFO)
00345 #define LOG4CPLUS_INFO(logger, logEvent)                                \
00346     LOG4CPLUS_MACRO_BODY (logger, logEvent, INFO_LOG_LEVEL)
00347 #define LOG4CPLUS_INFO_STR(logger, logEvent)                            \
00348     LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, INFO_LOG_LEVEL)
00349 
00350 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00351 #define LOG4CPLUS_INFO_FMT(logger, logFmt, ...)                             \
00352     LOG4CPLUS_MACRO_FMT_BODY (logger, INFO_LOG_LEVEL, logFmt, __VA_ARGS__)
00353 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00354 #define LOG4CPLUS_INFO_FMT(logger, logFmt, logArgs...)                      \
00355     LOG4CPLUS_MACRO_FMT_BODY(logger, INFO_LOG_LEVEL, logFmt, logArgs)
00356 #endif
00357 
00358 #else
00359 #define LOG4CPLUS_INFO(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00360 #define LOG4CPLUS_INFO_STR(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00361 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00362 #define LOG4CPLUS_INFO_FMT(logger, logFmt, ...) LOG4CPLUS_DOWHILE_NOTHING()
00363 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00364 #define LOG4CPLUS_INFO_FMT(logger, logFmt, logArgs...) LOG4CPLUS_DOWHILE_NOTHING()
00365 #endif
00366 
00367 #endif
00368 
00374 #if !defined(LOG4CPLUS_DISABLE_WARN)
00375 #define LOG4CPLUS_WARN(logger, logEvent)                                \
00376     LOG4CPLUS_MACRO_BODY (logger, logEvent, WARN_LOG_LEVEL)
00377 #define LOG4CPLUS_WARN_STR(logger, logEvent)                            \
00378     LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, WARN_LOG_LEVEL)
00379 
00380 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00381 #define LOG4CPLUS_WARN_FMT(logger, logFmt, ...)                             \
00382     LOG4CPLUS_MACRO_FMT_BODY (logger, WARN_LOG_LEVEL, logFmt, __VA_ARGS__)
00383 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00384 #define LOG4CPLUS_WARN_FMT(logger, logFmt, logArgs...)                      \
00385     LOG4CPLUS_MACRO_FMT_BODY(logger, WARN_LOG_LEVEL, logFmt, logArgs)
00386 #endif
00387 
00388 #else
00389 #define LOG4CPLUS_WARN(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00390 #define LOG4CPLUS_WARN_STR(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00391 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00392 #define LOG4CPLUS_WARN_FMT(logger, logFmt, ...) LOG4CPLUS_DOWHILE_NOTHING()
00393 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00394 #define LOG4CPLUS_WARN_FMT(logger, logFmt, logArgs...) LOG4CPLUS_DOWHILE_NOTHING()
00395 #endif
00396 
00397 #endif
00398 
00404 #if !defined(LOG4CPLUS_DISABLE_ERROR)
00405 #define LOG4CPLUS_ERROR(logger, logEvent)                               \
00406     LOG4CPLUS_MACRO_BODY (logger, logEvent, ERROR_LOG_LEVEL)
00407 #define LOG4CPLUS_ERROR_STR(logger, logEvent)                           \
00408     LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, ERROR_LOG_LEVEL)
00409 
00410 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00411 #define LOG4CPLUS_ERROR_FMT(logger, logFmt, ...)                            \
00412     LOG4CPLUS_MACRO_FMT_BODY (logger, ERROR_LOG_LEVEL, logFmt, __VA_ARGS__)
00413 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00414 #define LOG4CPLUS_ERROR_FMT(logger, logFmt, logArgs...)                     \
00415     LOG4CPLUS_MACRO_FMT_BODY(logger, ERROR_LOG_LEVEL, logFmt, logArgs)
00416 #endif
00417 
00418 #else
00419 #define LOG4CPLUS_ERROR(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00420 #define LOG4CPLUS_ERROR_STR(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00421 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00422 #define LOG4CPLUS_ERROR_FMT(logger, logFmt, ...) LOG4CPLUS_DOWHILE_NOTHING()
00423 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00424 #define LOG4CPLUS_ERROR_FMT(logger, logFmt, logArgs...) LOG4CPLUS_DOWHILE_NOTHING()
00425 #endif
00426 
00427 #endif
00428 
00434 #if !defined(LOG4CPLUS_DISABLE_FATAL)
00435 #define LOG4CPLUS_FATAL(logger, logEvent)                               \
00436     LOG4CPLUS_MACRO_BODY (logger, logEvent, FATAL_LOG_LEVEL)
00437 #define LOG4CPLUS_FATAL_STR(logger, logEvent)                           \
00438     LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, FATAL_LOG_LEVEL)
00439 
00440 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00441 #define LOG4CPLUS_FATAL_FMT(logger, logFmt, ...)                            \
00442     LOG4CPLUS_MACRO_FMT_BODY (logger, FATAL_LOG_LEVEL, logFmt, __VA_ARGS__)
00443 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00444 #define LOG4CPLUS_FATAL_FMT(logger, logFmt, logArgs...)                     \
00445     LOG4CPLUS_MACRO_FMT_BODY(logger, FATAL_LOG_LEVEL, logFmt, logArgs)
00446 #endif
00447 
00448 #else
00449 #define LOG4CPLUS_FATAL(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00450 #define LOG4CPLUS_FATAL_STR(logger, logEvent) LOG4CPLUS_DOWHILE_NOTHING()
00451 #if defined (LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
00452 #define LOG4CPLUS_FATAL_FMT(logger, logFmt, ...) LOG4CPLUS_DOWHILE_NOTHING()
00453 #elif defined (LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
00454 #define LOG4CPLUS_FATAL_FMT(logger, logFmt, logArgs...) LOG4CPLUS_DOWHILE_NOTHING()
00455 #endif
00456 
00457 #endif
00458 
00459 #endif /* LOG4CPLUS_LOGGING_MACROS_HEADER_ */