1 // -*- C++ -*-
2 // Module: Log4CPLUS
3 // File: logmacro.h
4 // Created: 8/2003
5 // Author: Tad E. Smith
6 //
7 //
8 // Copyright 2003-2010 Tad E. Smith
9 //
10 // Licensed under the Apache License, Version 2.0 (the "License");
11 // you may not use this file except in compliance with the License.
12 // You may obtain a copy of the License at
13 //
14 // http://www.apache.org/licenses/LICENSE-2.0
15 //
16 // Unless required by applicable law or agreed to in writing, software
17 // distributed under the License is distributed on an "AS IS" BASIS,
18 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19 // See the License for the specific language governing permissions and
20 // limitations under the License.
21
22 /** @file
23 * This header defines the logging macros. */
24
25 #ifndef DCMTK_LOG4CPLUS_LOGGING_MACROS_HEADER_
26 #define DCMTK_LOG4CPLUS_LOGGING_MACROS_HEADER_
27
28 #include "dcmtk/oflog/config.h"
29
30 #if defined (DCMTK_LOG4CPLUS_HAVE_PRAGMA_ONCE)
31 #pragma once
32 #endif
33
34 #include "dcmtk/oflog/streams.h"
35 #include "dcmtk/oflog/logger.h"
36 #include "dcmtk/oflog/helpers/snprintf.h"
37 #include "dcmtk/oflog/tracelog.h"
38 #include <sstream>
39 #include <utility>
40
41 #if defined(DCMTK_LOG4CPLUS_DISABLE_FATAL) && !defined(DCMTK_LOG4CPLUS_DISABLE_ERROR)
42 #define DCMTK_LOG4CPLUS_DISABLE_ERROR
43 #endif
44 #if defined(DCMTK_LOG4CPLUS_DISABLE_ERROR) && !defined(DCMTK_LOG4CPLUS_DISABLE_WARN)
45 #define DCMTK_LOG4CPLUS_DISABLE_WARN
46 #endif
47 #if defined(DCMTK_LOG4CPLUS_DISABLE_WARN) && !defined(DCMTK_LOG4CPLUS_DISABLE_INFO)
48 #define DCMTK_LOG4CPLUS_DISABLE_INFO
49 #endif
50 #if defined(DCMTK_LOG4CPLUS_DISABLE_INFO) && !defined(DCMTK_LOG4CPLUS_DISABLE_DEBUG)
51 #define DCMTK_LOG4CPLUS_DISABLE_DEBUG
52 #endif
53 #if defined(DCMTK_LOG4CPLUS_DISABLE_DEBUG) && !defined(DCMTK_LOG4CPLUS_DISABLE_TRACE)
54 #define DCMTK_LOG4CPLUS_DISABLE_TRACE
55 #endif
56
57
58 namespace dcmtk
59 {
60 namespace log4cplus
61 {
62
63 namespace detail
64 {
65
66
67 inline
68 Logger
macros_get_logger(Logger const & logger)69 macros_get_logger (Logger const & logger)
70 {
71 return logger;
72 }
73
74
75 inline
76 Logger const &
macros_get_logger(Logger & logger)77 macros_get_logger (Logger & logger)
78 {
79 return logger;
80 }
81
82
83 #if defined (DCMTK_LOG4CPLUS_HAVE_RVALUE_REFS)
84 inline
85 Logger
macros_get_logger(Logger && logger)86 macros_get_logger (Logger && logger)
87 {
88 return STD_NAMESPACE move (logger);
89 }
90
91 #endif
92
93
94 inline
95 Logger
macros_get_logger(tstring const & logger)96 macros_get_logger (tstring const & logger)
97 {
98 return Logger::getInstance (logger);
99 }
100
101
102 inline
103 Logger
macros_get_logger(tchar const * logger)104 macros_get_logger (tchar const * logger)
105 {
106 return Logger::getInstance (logger);
107 }
108
109
110 DCMTK_LOG4CPLUS_EXPORT void clear_tostringstream (tostringstream &);
111
112
113 DCMTK_LOG4CPLUS_EXPORT log4cplus::tostringstream & get_macro_body_oss ();
114 DCMTK_LOG4CPLUS_EXPORT log4cplus::helpers::snprintf_buf & get_macro_body_snprintf_buf ();
115 DCMTK_LOG4CPLUS_EXPORT void macro_forced_log (log4cplus::Logger const &,
116 log4cplus::LogLevel, log4cplus::tstring const &, char const *, int,
117 char const *);
118
119
120 } // namespace detail
121
122 } // namespace log4cplus
123 } // end namespace dcmtk
124
125
126 #undef DCMTK_LOG4CPLUS_MACRO_FUNCTION
127 #define DCMTK_LOG4CPLUS_MACRO_FUNCTION() 0
128 #if ! defined (DCMTK_LOG4CPLUS_DISABLE_FUNCTION_MACRO)
129 # if defined (DCMTK_LOG4CPLUS_HAVE_FUNCSIG_MACRO)
130 # undef DCMTK_LOG4CPLUS_MACRO_FUNCTION
131 # define DCMTK_LOG4CPLUS_MACRO_FUNCTION() __FUNCSIG__
132 # elif defined (DCMTK_LOG4CPLUS_HAVE_PRETTY_FUNCTION_MACRO)
133 # undef DCMTK_LOG4CPLUS_MACRO_FUNCTION
134 # define DCMTK_LOG4CPLUS_MACRO_FUNCTION() __PRETTY_FUNCTION__
135 # elif defined (DCMTK_LOG4CPLUS_HAVE_FUNCTION_MACRO)
136 # undef DCMTK_LOG4CPLUS_MACRO_FUNCTION
137 # define DCMTK_LOG4CPLUS_MACRO_FUNCTION() __FUNCTION__
138 # elif defined (DCMTK_LOG4CPLUS_HAVE_FUNC_SYMBOL)
139 # undef DCMTK_LOG4CPLUS_MACRO_FUNCTION
140 # define DCMTK_LOG4CPLUS_MACRO_FUNCTION() __func__
141 # endif
142 #endif
143
144
145 // Make TRACE and DEBUG log level unlikely and INFO, WARN, ERROR and
146 // FATAL log level likely.
147 #define DCMTK_LOG4CPLUS_MACRO_TRACE_LOG_LEVEL(pred) \
148 DCMTK_LOG4CPLUS_UNLIKELY (pred)
149 #define DCMTK_LOG4CPLUS_MACRO_DEBUG_LOG_LEVEL(pred) \
150 DCMTK_LOG4CPLUS_UNLIKELY (pred)
151 #define DCMTK_LOG4CPLUS_MACRO_INFO_LOG_LEVEL(pred) \
152 DCMTK_LOG4CPLUS_LIKELY (pred)
153 #define DCMTK_LOG4CPLUS_MACRO_WARN_LOG_LEVEL(pred) \
154 DCMTK_LOG4CPLUS_LIKELY (pred)
155 #define DCMTK_LOG4CPLUS_MACRO_ERROR_LOG_LEVEL(pred) \
156 DCMTK_LOG4CPLUS_LIKELY (pred)
157 #define DCMTK_LOG4CPLUS_MACRO_FATAL_LOG_LEVEL(pred) \
158 DCMTK_LOG4CPLUS_LIKELY (pred)
159
160
161 //! Dispatch to DCMTK_LOG4CPLUS_MACRO_LOGLEVEL_* depending on log level.
162 #define DCMTK_LOG4CPLUS_MACRO_LOGLEVEL_PRED(pred, logLevel) \
163 DCMTK_LOG4CPLUS_MACRO_ ## logLevel (pred)
164
165
166 #define DCMTK_LOG4CPLUS_MACRO_BODY(logger, logEvent, logLevel) \
167 do { \
168 dcmtk::log4cplus::Logger const & _l \
169 = dcmtk::log4cplus::detail::macros_get_logger (logger); \
170 if (DCMTK_LOG4CPLUS_MACRO_LOGLEVEL_PRED ( \
171 _l.isEnabledFor (dcmtk::log4cplus::logLevel), logLevel)) { \
172 dcmtk::log4cplus::tostringstream & _log4cplus_buf \
173 = dcmtk::log4cplus::detail::get_macro_body_oss (); \
174 _log4cplus_buf << logEvent; \
175 dcmtk::log4cplus::detail::macro_forced_log (_l, \
176 dcmtk::log4cplus::logLevel, OFString(_log4cplus_buf.str().c_str(), _log4cplus_buf.str().length()), \
177 __FILE__, __LINE__, DCMTK_LOG4CPLUS_MACRO_FUNCTION ()); \
178 } \
179 } while (0)
180
181
182 #define DCMTK_LOG4CPLUS_MACRO_STR_BODY(logger, logEvent, logLevel) \
183 do { \
184 dcmtk::log4cplus::Logger const & _l \
185 = dcmtk::log4cplus::detail::macros_get_logger (logger); \
186 if (DCMTK_LOG4CPLUS_MACRO_LOGLEVEL_PRED ( \
187 _l.isEnabledFor (dcmtk::log4cplus::logLevel), logLevel)) { \
188 dcmtk::log4cplus::detail::macro_forced_log (_l, \
189 dcmtk::log4cplus::logLevel, logEvent, \
190 __FILE__, __LINE__, DCMTK_LOG4CPLUS_MACRO_FUNCTION ()); \
191 } \
192 } while(0)
193
194 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
195 #define DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, logLevel, logFmt, ...) \
196 do { \
197 dcmtk::log4cplus::Logger const & _l \
198 = dcmtk::log4cplus::detail::macros_get_logger (logger); \
199 if (DCMTK_LOG4CPLUS_MACRO_LOGLEVEL_PRED ( \
200 _l.isEnabledFor (dcmtk::log4cplus::logLevel), logLevel)) { \
201 dcmtk::log4cplus::helpers::snprintf_buf & _snpbuf \
202 = dcmtk::log4cplus::detail::get_macro_body_snprintf_buf (); \
203 dcmtk::log4cplus::tchar const * _logEvent \
204 = _snpbuf.print (logFmt, __VA_ARGS__); \
205 dcmtk::log4cplus::detail::macro_forced_log (_l, \
206 dcmtk::log4cplus::logLevel, _logEvent, \
207 __FILE__, __LINE__, DCMTK_LOG4CPLUS_MACRO_FUNCTION ()); \
208 } \
209 } while(0)
210
211 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
212 #define DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, logLevel, logFmt, logArgs...) \
213 do { \
214 dcmtk::log4cplus::Logger const & _l \
215 = dcmtk::log4cplus::detail::macros_get_logger (logger); \
216 if (DCMTK_LOG4CPLUS_MACRO_LOGLEVEL_PRED ( \
217 _l.isEnabledFor (dcmtk::log4cplus::logLevel), logLevel)) { \
218 dcmtk::log4cplus::helpers::snprintf_buf & _snpbuf \
219 = dcmtk::log4cplus::detail::get_macro_body_snprintf_buf (); \
220 dcmtk::log4cplus::tchar const * _logEvent \
221 = _snpbuf.print (logFmt, logArgs); \
222 dcmtk::log4cplus::detail::macro_forced_log (_l, \
223 dcmtk::log4cplus::logLevel, _logEvent, \
224 __FILE__, __LINE__, DCMTK_LOG4CPLUS_MACRO_FUNCTION ()); \
225 } \
226 } while(0)
227
228 #endif
229
230
231 /**
232 * @def DCMTK_LOG4CPLUS_TRACE(logger, logEvent) This macro creates a
233 * TraceLogger to log a TRACE_LOG_LEVEL message to <code>logger</code>
234 * upon entry and exiting of a method.
235 * <code>logEvent</code> will be streamed into an <code>ostream</code>.
236 */
237 #if !defined(DCMTK_LOG4CPLUS_DISABLE_TRACE)
238 #define DCMTK_LOG4CPLUS_TRACE_METHOD(logger, logEvent) \
239 dcmtk::log4cplus::TraceLogger _log4cplus_trace_logger(logger, logEvent, \
240 __FILE__, __LINE__);
241 #define DCMTK_LOG4CPLUS_TRACE(logger, logEvent) \
242 DCMTK_LOG4CPLUS_MACRO_BODY (logger, logEvent, TRACE_LOG_LEVEL)
243 #define DCMTK_LOG4CPLUS_TRACE_STR(logger, logEvent) \
244 DCMTK_LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, TRACE_LOG_LEVEL)
245
246 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
247 #define DCMTK_LOG4CPLUS_TRACE_FMT(logger, logFmt, ...) \
248 DCMTK_LOG4CPLUS_MACRO_FMT_BODY (logger, TRACE_LOG_LEVEL, logFmt, __VA_ARGS__)
249 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
250 #define DCMTK_LOG4CPLUS_TRACE_FMT(logger, logFmt, logArgs...) \
251 DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, TRACE_LOG_LEVEL, logFmt, logArgs)
252 #endif
253
254 #else
255 #define DCMTK_LOG4CPLUS_TRACE_METHOD(logger, logEvent) do { } while (0)
256 #define DCMTK_LOG4CPLUS_TRACE(logger, logEvent) do { } while (0)
257 #define DCMTK_LOG4CPLUS_TRACE_STR(logger, logEvent) do { } while (0)
258 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
259 #define DCMTK_LOG4CPLUS_TRACE_FMT(logger, logFmt, ...) do { } while (0)
260 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
261 #define DCMTK_LOG4CPLUS_TRACE_FMT(logger, logFmt, logArgs...) do { } while (0)
262 #endif
263
264 #endif
265
266 /**
267 * @def DCMTK_LOG4CPLUS_DEBUG(logger, logEvent) This macro is used to log a
268 * DEBUG_LOG_LEVEL message to <code>logger</code>.
269 * <code>logEvent</code> will be streamed into an <code>ostream</code>.
270 */
271 #if !defined(DCMTK_LOG4CPLUS_DISABLE_DEBUG)
272 #define DCMTK_LOG4CPLUS_DEBUG(logger, logEvent) \
273 DCMTK_LOG4CPLUS_MACRO_BODY (logger, logEvent, DEBUG_LOG_LEVEL)
274 #define DCMTK_LOG4CPLUS_DEBUG_STR(logger, logEvent) \
275 DCMTK_LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, DEBUG_LOG_LEVEL)
276
277 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
278 #define DCMTK_LOG4CPLUS_DEBUG_FMT(logger, logFmt, ...) \
279 DCMTK_LOG4CPLUS_MACRO_FMT_BODY (logger, DEBUG_LOG_LEVEL, logFmt, __VA_ARGS__)
280 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
281 #define DCMTK_LOG4CPLUS_DEBUG_FMT(logger, logFmt, logArgs...) \
282 DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, DEBUG_LOG_LEVEL, logFmt, logArgs)
283 #endif
284
285 #else
286 #define DCMTK_LOG4CPLUS_DEBUG(logger, logEvent) do { } while (0)
287 #define DCMTK_LOG4CPLUS_DEBUG_STR(logger, logEvent) do { } while (0)
288 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
289 #define DCMTK_LOG4CPLUS_DEBUG_FMT(logger, logFmt, ...) do { } while (0)
290 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
291 #define DCMTK_LOG4CPLUS_DEBUG_FMT(logger, logFmt, logArgs...) do { } while (0)
292 #endif
293
294 #endif
295
296 /**
297 * @def DCMTK_LOG4CPLUS_INFO(logger, logEvent) This macro is used to log a
298 * INFO_LOG_LEVEL message to <code>logger</code>.
299 * <code>logEvent</code> will be streamed into an <code>ostream</code>.
300 */
301 #if !defined(DCMTK_LOG4CPLUS_DISABLE_INFO)
302 #define DCMTK_LOG4CPLUS_INFO(logger, logEvent) \
303 DCMTK_LOG4CPLUS_MACRO_BODY (logger, logEvent, INFO_LOG_LEVEL)
304 #define DCMTK_LOG4CPLUS_INFO_STR(logger, logEvent) \
305 DCMTK_LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, INFO_LOG_LEVEL)
306
307 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
308 #define DCMTK_LOG4CPLUS_INFO_FMT(logger, logFmt, ...) \
309 DCMTK_LOG4CPLUS_MACRO_FMT_BODY (logger, INFO_LOG_LEVEL, logFmt, __VA_ARGS__)
310 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
311 #define DCMTK_LOG4CPLUS_INFO_FMT(logger, logFmt, logArgs...) \
312 DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, INFO_LOG_LEVEL, logFmt, logArgs)
313 #endif
314
315 #else
316 #define DCMTK_LOG4CPLUS_INFO(logger, logEvent) do { } while (0)
317 #define DCMTK_LOG4CPLUS_INFO_STR(logger, logEvent) do { } while (0)
318 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
319 #define DCMTK_LOG4CPLUS_INFO_FMT(logger, logFmt, ...) do { } while (0)
320 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
321 #define DCMTK_LOG4CPLUS_INFO_FMT(logger, logFmt, logArgs...) do { } while (0)
322 #endif
323
324 #endif
325
326 /**
327 * @def DCMTK_LOG4CPLUS_WARN(logger, logEvent) This macro is used to log a
328 * WARN_LOG_LEVEL message to <code>logger</code>.
329 * <code>logEvent</code> will be streamed into an <code>ostream</code>.
330 */
331 #if !defined(DCMTK_LOG4CPLUS_DISABLE_WARN)
332 #define DCMTK_LOG4CPLUS_WARN(logger, logEvent) \
333 DCMTK_LOG4CPLUS_MACRO_BODY (logger, logEvent, WARN_LOG_LEVEL)
334 #define DCMTK_LOG4CPLUS_WARN_STR(logger, logEvent) \
335 DCMTK_LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, WARN_LOG_LEVEL)
336
337 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
338 #define DCMTK_LOG4CPLUS_WARN_FMT(logger, logFmt, ...) \
339 DCMTK_LOG4CPLUS_MACRO_FMT_BODY (logger, WARN_LOG_LEVEL, logFmt, __VA_ARGS__)
340 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
341 #define DCMTK_LOG4CPLUS_WARN_FMT(logger, logFmt, logArgs...) \
342 DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, WARN_LOG_LEVEL, logFmt, logArgs)
343 #endif
344
345 #else
346 #define DCMTK_LOG4CPLUS_WARN(logger, logEvent) do { } while (0)
347 #define DCMTK_LOG4CPLUS_WARN_STR(logger, logEvent) do { } while (0)
348 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
349 #define DCMTK_LOG4CPLUS_WARN_FMT(logger, logFmt, ...) do { } while (0)
350 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
351 #define DCMTK_LOG4CPLUS_WARN_FMT(logger, logFmt, logArgs...) do { } while (0)
352 #endif
353
354 #endif
355
356 /**
357 * @def DCMTK_LOG4CPLUS_ERROR(logger, logEvent) This macro is used to log a
358 * ERROR_LOG_LEVEL message to <code>logger</code>.
359 * <code>logEvent</code> will be streamed into an <code>ostream</code>.
360 */
361 #if !defined(DCMTK_LOG4CPLUS_DISABLE_ERROR)
362 #define DCMTK_LOG4CPLUS_ERROR(logger, logEvent) \
363 DCMTK_LOG4CPLUS_MACRO_BODY (logger, logEvent, ERROR_LOG_LEVEL)
364 #define DCMTK_LOG4CPLUS_ERROR_STR(logger, logEvent) \
365 DCMTK_LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, ERROR_LOG_LEVEL)
366
367 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
368 #define DCMTK_LOG4CPLUS_ERROR_FMT(logger, logFmt, ...) \
369 DCMTK_LOG4CPLUS_MACRO_FMT_BODY (logger, ERROR_LOG_LEVEL, logFmt, __VA_ARGS__)
370 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
371 #define DCMTK_LOG4CPLUS_ERROR_FMT(logger, logFmt, logArgs...) \
372 DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, ERROR_LOG_LEVEL, logFmt, logArgs)
373 #endif
374
375 #else
376 #define DCMTK_LOG4CPLUS_ERROR(logger, logEvent) do { } while (0)
377 #define DCMTK_LOG4CPLUS_ERROR_STR(logger, logEvent) do { } while (0)
378 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
379 #define DCMTK_LOG4CPLUS_ERROR_FMT(logger, logFmt, ...) do { } while (0)
380 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
381 #define DCMTK_LOG4CPLUS_ERROR_FMT(logger, logFmt, logArgs...) do { } while (0)
382 #endif
383
384 #endif
385
386 /**
387 * @def DCMTK_LOG4CPLUS_FATAL(logger, logEvent) This macro is used to log a
388 * FATAL_LOG_LEVEL message to <code>logger</code>.
389 * <code>logEvent</code> will be streamed into an <code>ostream</code>.
390 */
391 #if !defined(DCMTK_LOG4CPLUS_DISABLE_FATAL)
392 #define DCMTK_LOG4CPLUS_FATAL(logger, logEvent) \
393 DCMTK_LOG4CPLUS_MACRO_BODY (logger, logEvent, FATAL_LOG_LEVEL)
394 #define DCMTK_LOG4CPLUS_FATAL_STR(logger, logEvent) \
395 DCMTK_LOG4CPLUS_MACRO_STR_BODY (logger, logEvent, FATAL_LOG_LEVEL)
396
397 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
398 #define DCMTK_LOG4CPLUS_FATAL_FMT(logger, logFmt, ...) \
399 DCMTK_LOG4CPLUS_MACRO_FMT_BODY (logger, FATAL_LOG_LEVEL, logFmt, __VA_ARGS__)
400 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
401 #define DCMTK_LOG4CPLUS_FATAL_FMT(logger, logFmt, logArgs...) \
402 DCMTK_LOG4CPLUS_MACRO_FMT_BODY(logger, FATAL_LOG_LEVEL, logFmt, logArgs)
403 #endif
404
405 #else
406 #define DCMTK_LOG4CPLUS_FATAL(logger, logEvent) do { } while (0)
407 #define DCMTK_LOG4CPLUS_FATAL_STR(logger, logEvent) do { } while (0)
408 #if defined (DCMTK_LOG4CPLUS_HAVE_C99_VARIADIC_MACROS)
409 #define DCMTK_LOG4CPLUS_FATAL_FMT(logger, logFmt, ...) do { } while (0)
410 #elif defined (DCMTK_LOG4CPLUS_HAVE_GNU_VARIADIC_MACROS)
411 #define DCMTK_LOG4CPLUS_FATAL_FMT(logger, logFmt, logArgs...) do { } while (0)
412 #endif
413
414 #endif
415
416 #endif /* DCMTK_LOG4CPLUS_LOGGING_MACROS_HEADER_ */
417