e200fc3beb038e1d63f860290524caae6c2b8f9e
[framework/web/webkit-efl.git] / Source / WTF / wtf / Assertions.h
1 /*
2  * Copyright (C) 2003, 2006, 2007 Apple Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef WTF_Assertions_h
27 #define WTF_Assertions_h
28
29 /*
30    no namespaces because this file has to be includable from C and Objective-C
31
32    Note, this file uses many GCC extensions, but it should be compatible with
33    C, Objective C, C++, and Objective C++.
34
35    For non-debug builds, everything is disabled by default.
36    Defining any of the symbols explicitly prevents this from having any effect.
37    
38    MSVC7 note: variadic macro support was added in MSVC8, so for now we disable
39    those macros in MSVC7. For more info, see the MSDN document on variadic 
40    macros here:
41    
42    http://msdn2.microsoft.com/en-us/library/ms177415(VS.80).aspx
43 */
44
45 #include <wtf/Platform.h>
46
47 #include <stddef.h>
48
49 #if !COMPILER(MSVC)
50 #include <inttypes.h>
51 #endif
52
53 #ifdef NDEBUG
54 /* Disable ASSERT* macros in release mode. */
55 #define ASSERTIONS_DISABLED_DEFAULT 1
56 #else
57 #define ASSERTIONS_DISABLED_DEFAULT 0
58 #endif
59
60 #if COMPILER(MSVC7_OR_LOWER)
61 #define HAVE_VARIADIC_MACRO 0
62 #else
63 #define HAVE_VARIADIC_MACRO 1
64 #endif
65
66 #ifndef BACKTRACE_DISABLED
67 #define BACKTRACE_DISABLED ASSERTIONS_DISABLED_DEFAULT
68 #endif
69
70 #ifndef ASSERT_DISABLED
71 #define ASSERT_DISABLED ASSERTIONS_DISABLED_DEFAULT
72 #endif
73
74 #ifndef ASSERT_MSG_DISABLED
75 #if HAVE(VARIADIC_MACRO)
76 #define ASSERT_MSG_DISABLED ASSERTIONS_DISABLED_DEFAULT
77 #else
78 #define ASSERT_MSG_DISABLED 1
79 #endif
80 #endif
81
82 #ifndef ASSERT_ARG_DISABLED
83 #define ASSERT_ARG_DISABLED ASSERTIONS_DISABLED_DEFAULT
84 #endif
85
86 #ifndef FATAL_DISABLED
87 #if HAVE(VARIADIC_MACRO)
88 #define FATAL_DISABLED ASSERTIONS_DISABLED_DEFAULT
89 #else
90 #define FATAL_DISABLED 1
91 #endif
92 #endif
93
94 #ifndef ERROR_DISABLED
95 #if HAVE(VARIADIC_MACRO)
96 #define ERROR_DISABLED ASSERTIONS_DISABLED_DEFAULT
97 #else
98 #define ERROR_DISABLED 1
99 #endif
100 #endif
101
102 #ifndef LOG_DISABLED
103 #if HAVE(VARIADIC_MACRO)
104 #define LOG_DISABLED ASSERTIONS_DISABLED_DEFAULT
105 #else
106 #define LOG_DISABLED 1
107 #endif
108 #endif
109
110 #if COMPILER(GCC)
111 #define WTF_PRETTY_FUNCTION __PRETTY_FUNCTION__
112 #else
113 #define WTF_PRETTY_FUNCTION __FUNCTION__
114 #endif
115
116 /* WTF logging functions can process %@ in the format string to log a NSObject* but the printf format attribute
117    emits a warning when %@ is used in the format string.  Until <rdar://problem/5195437> is resolved we can't include
118    the attribute when being used from Objective-C code in case it decides to use %@. */
119 #if COMPILER(GCC) && !defined(__OBJC__)
120 #define WTF_ATTRIBUTE_PRINTF(formatStringArgument, extraArguments) __attribute__((__format__(printf, formatStringArgument, extraArguments)))
121 #else
122 #define WTF_ATTRIBUTE_PRINTF(formatStringArgument, extraArguments) 
123 #endif
124
125 /* These helper functions are always declared, but not necessarily always defined if the corresponding function is disabled. */
126
127 #ifdef __cplusplus
128 extern "C" {
129 #endif
130
131 typedef enum { WTFLogChannelOff, WTFLogChannelOn } WTFLogChannelState;
132
133 typedef struct {
134     unsigned mask;
135     const char *defaultName;
136     WTFLogChannelState state;
137 } WTFLogChannel;
138
139 WTF_EXPORT_PRIVATE void WTFReportAssertionFailure(const char* file, int line, const char* function, const char* assertion);
140 WTF_EXPORT_PRIVATE void WTFReportAssertionFailureWithMessage(const char* file, int line, const char* function, const char* assertion, const char* format, ...) WTF_ATTRIBUTE_PRINTF(5, 6);
141 WTF_EXPORT_PRIVATE void WTFReportArgumentAssertionFailure(const char* file, int line, const char* function, const char* argName, const char* assertion);
142 WTF_EXPORT_PRIVATE void WTFReportFatalError(const char* file, int line, const char* function, const char* format, ...) WTF_ATTRIBUTE_PRINTF(4, 5);
143 WTF_EXPORT_PRIVATE void WTFReportError(const char* file, int line, const char* function, const char* format, ...) WTF_ATTRIBUTE_PRINTF(4, 5);
144 WTF_EXPORT_PRIVATE void WTFLog(WTFLogChannel*, const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
145 WTF_EXPORT_PRIVATE void WTFLogVerbose(const char* file, int line, const char* function, WTFLogChannel*, const char* format, ...) WTF_ATTRIBUTE_PRINTF(5, 6);
146 WTF_EXPORT_PRIVATE void WTFLogAlways(const char* format, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
147
148 WTF_EXPORT_PRIVATE void WTFGetBacktrace(void** stack, int* size);
149 WTF_EXPORT_PRIVATE void WTFReportBacktrace();
150 WTF_EXPORT_PRIVATE void WTFPrintBacktrace(void** stack, int size);
151
152 typedef void (*WTFCrashHookFunction)();
153 WTF_EXPORT_PRIVATE void WTFSetCrashHook(WTFCrashHookFunction);
154 WTF_EXPORT_PRIVATE void WTFInvokeCrashHook();
155
156 #if ENABLE(TIZEN_DLOG_SUPPORT)
157 WTF_EXPORT_PRIVATE void TizenLogError(int line, const char* function, const char* format, ...);
158 WTF_EXPORT_PRIVATE void TizenLogInfo(int line, const char* function, const char* format, ...);
159 #endif
160
161 #ifdef __cplusplus
162 }
163 #endif
164
165 /* CRASH() - Raises a fatal error resulting in program termination and triggering either the debugger or the crash reporter.
166
167    Use CRASH() in response to known, unrecoverable errors like out-of-memory.
168    Macro is enabled in both debug and release mode.
169    To test for unknown errors and verify assumptions, use ASSERT instead, to avoid impacting performance in release builds.
170
171    Signals are ignored by the crash reporter on OS X so we must do better.
172 */
173 #ifndef CRASH
174 #if COMPILER(CLANG)
175 #define CRASH() \
176     (WTFReportBacktrace(), \
177      WTFInvokeCrashHook(), \
178      (*(int *)(uintptr_t)0xbbadbeef = 0), \
179      __builtin_trap())
180 #else
181 #define CRASH() \
182     (WTFReportBacktrace(), \
183      WTFInvokeCrashHook(), \
184      (*(int *)(uintptr_t)0xbbadbeef = 0), \
185      ((void(*)())0)() /* More reliable, but doesn't say BBADBEEF */ \
186     )
187 #endif
188 #endif
189
190 #if COMPILER(CLANG)
191 #define NO_RETURN_DUE_TO_CRASH NO_RETURN
192 #else
193 #define NO_RETURN_DUE_TO_CRASH
194 #endif
195
196
197 /* BACKTRACE
198
199   Print a backtrace to the same location as ASSERT messages.
200 */
201
202 #if BACKTRACE_DISABLED
203
204 #define BACKTRACE() ((void)0)
205
206 #else
207
208 #define BACKTRACE() do { \
209     WTFReportBacktrace(); \
210 } while(false)
211
212 #endif
213
214 /* ASSERT, ASSERT_NOT_REACHED, ASSERT_UNUSED
215
216   These macros are compiled out of release builds.
217   Expressions inside them are evaluated in debug builds only.
218 */
219
220 #if OS(WINCE) && !PLATFORM(TORCHMOBILE)
221 /* FIXME: We include this here only to avoid a conflict with the ASSERT macro. */
222 #include <windows.h>
223 #undef min
224 #undef max
225 #undef ERROR
226 #endif
227
228 #if OS(WINDOWS)
229 /* FIXME: Change to use something other than ASSERT to avoid this conflict with the underlying platform */
230 #undef ASSERT
231 #endif
232
233 #if ASSERT_DISABLED
234
235 #define ASSERT(assertion) ((void)0)
236 #define ASSERT_AT(assertion, file, line, function) ((void)0)
237 #define ASSERT_NOT_REACHED() ((void)0)
238 #define NO_RETURN_DUE_TO_ASSERT
239
240 #if COMPILER(INTEL) && !OS(WINDOWS) || COMPILER(RVCT)
241 template<typename T>
242 inline void assertUnused(T& x) { (void)x; }
243 #define ASSERT_UNUSED(variable, assertion) (assertUnused(variable))
244 #else
245 #define ASSERT_UNUSED(variable, assertion) ((void)variable)
246 #endif
247
248 #else
249
250 #define ASSERT(assertion) \
251     (!(assertion) ? \
252         (WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion), \
253          CRASH()) : \
254         (void)0)
255
256 #define ASSERT_AT(assertion, file, line, function) \
257     (!(assertion) ? \
258         (WTFReportAssertionFailure(file, line, function, #assertion), \
259          CRASH()) :                                                   \
260         (void)0)
261
262 #define ASSERT_NOT_REACHED() do { \
263     WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, 0); \
264     CRASH(); \
265 } while (0)
266
267 #define ASSERT_UNUSED(variable, assertion) ASSERT(assertion)
268
269 #define NO_RETURN_DUE_TO_ASSERT NO_RETURN_DUE_TO_CRASH
270
271 #endif
272
273 /* ASSERT_WITH_MESSAGE */
274
275 #if COMPILER(MSVC7_OR_LOWER)
276 #define ASSERT_WITH_MESSAGE(assertion) ((void)0)
277 #elif ASSERT_MSG_DISABLED
278 #define ASSERT_WITH_MESSAGE(assertion, ...) ((void)0)
279 #else
280 #define ASSERT_WITH_MESSAGE(assertion, ...) do \
281     if (!(assertion)) { \
282         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
283         CRASH(); \
284     } \
285 while (0)
286 #endif
287
288 /* ASSERT_WITH_MESSAGE_UNUSED */
289
290 #if COMPILER(MSVC7_OR_LOWER)
291 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion) ((void)0)
292 #elif ASSERT_MSG_DISABLED
293 #if COMPILER(INTEL) && !OS(WINDOWS) || COMPILER(RVCT)
294 template<typename T>
295 inline void assertWithMessageUnused(T& x) { (void)x; }
296 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) (assertWithMessageUnused(variable))
297 #else
298 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) ((void)variable)
299 #endif
300 #else
301 #define ASSERT_WITH_MESSAGE_UNUSED(variable, assertion, ...) do \
302     if (!(assertion)) { \
303         WTFReportAssertionFailureWithMessage(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion, __VA_ARGS__); \
304         CRASH(); \
305     } \
306 while (0)
307 #endif
308                         
309                         
310 /* ASSERT_ARG */
311
312 #if ASSERT_ARG_DISABLED
313
314 #define ASSERT_ARG(argName, assertion) ((void)0)
315
316 #else
317
318 #define ASSERT_ARG(argName, assertion) do \
319     if (!(assertion)) { \
320         WTFReportArgumentAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #argName, #assertion); \
321         CRASH(); \
322     } \
323 while (0)
324
325 #endif
326
327 /* COMPILE_ASSERT */
328 #ifndef COMPILE_ASSERT
329 #if COMPILER_SUPPORTS(C_STATIC_ASSERT)
330 #define COMPILE_ASSERT(exp, name) _Static_assert((exp), #name)
331 #else
332 #define COMPILE_ASSERT(exp, name) typedef int dummy##name [(exp) ? 1 : -1]
333 #endif
334 #endif
335
336 /* FATAL */
337
338 #if COMPILER(MSVC7_OR_LOWER)
339 #define FATAL() ((void)0)
340 #elif FATAL_DISABLED
341 #define FATAL(...) ((void)0)
342 #else
343 #define FATAL(...) do { \
344     WTFReportFatalError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__); \
345     CRASH(); \
346 } while (0)
347 #endif
348
349 /* LOG_ERROR */
350
351 #if COMPILER(MSVC7_OR_LOWER)
352 #define LOG_ERROR() ((void)0)
353 #elif ERROR_DISABLED
354 #define LOG_ERROR(...) ((void)0)
355 #else
356 #define LOG_ERROR(...) WTFReportError(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__)
357 #endif
358
359 /* LOG */
360
361 #if COMPILER(MSVC7_OR_LOWER)
362 #define LOG() ((void)0)
363 #elif LOG_DISABLED
364 #define LOG(channel, ...) ((void)0)
365 #else
366 #if ENABLE(TIZEN_DLOG_SUPPORT)
367 // Use below macros to print out WebKit debug log.
368 #define TIZEN_LOGE(...) TizenLogError(__LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
369 #define TIZEN_LOGI(...) TizenLogInfo(__LINE__, WTF_PRETTY_FUNCTION, __VA_ARGS__);
370
371 #define LOG(channel, ...) LOG_VERBOSE(channel, __VA_ARGS__)
372 #else
373 #define LOG(channel, ...) WTFLog(&JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
374 #endif
375 #define JOIN_LOG_CHANNEL_WITH_PREFIX(prefix, channel) JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel)
376 #define JOIN_LOG_CHANNEL_WITH_PREFIX_LEVEL_2(prefix, channel) prefix ## channel
377 #endif
378
379 /* LOG_VERBOSE */
380
381 #if COMPILER(MSVC7_OR_LOWER)
382 #define LOG_VERBOSE(channel) ((void)0)
383 #elif LOG_DISABLED
384 #define LOG_VERBOSE(channel, ...) ((void)0)
385 #else
386 #define LOG_VERBOSE(channel, ...) WTFLogVerbose(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, &JOIN_LOG_CHANNEL_WITH_PREFIX(LOG_CHANNEL_PREFIX, channel), __VA_ARGS__)
387 #endif
388
389 /* UNREACHABLE_FOR_PLATFORM */
390
391 #if COMPILER(CLANG)
392 // This would be a macro except that its use of #pragma works best around
393 // a function. Hence it uses macro naming convention.
394 #pragma clang diagnostic push
395 #pragma clang diagnostic ignored "-Wmissing-noreturn"
396 static inline void UNREACHABLE_FOR_PLATFORM()
397 {
398     ASSERT_NOT_REACHED();
399 }
400 #pragma clang diagnostic pop
401 #else
402 #define UNREACHABLE_FOR_PLATFORM() ASSERT_NOT_REACHED()
403 #endif
404
405 #endif /* WTF_Assertions_h */