1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 /*
19 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
20 * file for a list of people on the GLib Team. See the ChangeLog
21 * files for a list of changes. These files are distributed with
22 * GLib at ftp://ftp.gtk.org/pub/gtk/.
23 */
24
25 #ifndef __G_MESSAGES_H__
26 #define __G_MESSAGES_H__
27
28 #if !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
29 #error "Only <glib.h> can be included directly."
30 #endif
31
32 #include <stdarg.h>
33 #include <glib/gtypes.h>
34 #include <glib/gmacros.h>
35 #include <glib/gvariant.h>
36
37 G_BEGIN_DECLS
38
39 /* calculate a string size, guaranteed to fit format + args.
40 */
41 GLIB_AVAILABLE_IN_ALL
42 gsize g_printf_string_upper_bound (const gchar* format,
43 va_list args) G_GNUC_PRINTF(1, 0);
44
45 /* Log level shift offset for user defined
46 * log levels (0-7 are used by GLib).
47 */
48 #define G_LOG_LEVEL_USER_SHIFT (8)
49
50 /* Glib log levels and flags.
51 */
52 typedef enum
53 {
54 /* log flags */
55 G_LOG_FLAG_RECURSION = 1 << 0,
56 G_LOG_FLAG_FATAL = 1 << 1,
57
58 /* GLib log levels */
59 G_LOG_LEVEL_ERROR = 1 << 2, /* always fatal */
60 G_LOG_LEVEL_CRITICAL = 1 << 3,
61 G_LOG_LEVEL_WARNING = 1 << 4,
62 G_LOG_LEVEL_MESSAGE = 1 << 5,
63 G_LOG_LEVEL_INFO = 1 << 6,
64 G_LOG_LEVEL_DEBUG = 1 << 7,
65
66 G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
67 } GLogLevelFlags;
68
69 /* GLib log levels that are considered fatal by default */
70 #define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR)
71
72 typedef void (*GLogFunc) (const gchar *log_domain,
73 GLogLevelFlags log_level,
74 const gchar *message,
75 gpointer user_data);
76
77 /* Logging mechanism
78 */
79 GLIB_AVAILABLE_IN_ALL
80 guint g_log_set_handler (const gchar *log_domain,
81 GLogLevelFlags log_levels,
82 GLogFunc log_func,
83 gpointer user_data);
84 GLIB_AVAILABLE_IN_2_46
85 guint g_log_set_handler_full (const gchar *log_domain,
86 GLogLevelFlags log_levels,
87 GLogFunc log_func,
88 gpointer user_data,
89 GDestroyNotify destroy);
90 GLIB_AVAILABLE_IN_ALL
91 void g_log_remove_handler (const gchar *log_domain,
92 guint handler_id);
93 GLIB_AVAILABLE_IN_ALL
94 void g_log_default_handler (const gchar *log_domain,
95 GLogLevelFlags log_level,
96 const gchar *message,
97 gpointer unused_data);
98 GLIB_AVAILABLE_IN_ALL
99 GLogFunc g_log_set_default_handler (GLogFunc log_func,
100 gpointer user_data);
101 GLIB_AVAILABLE_IN_ALL
102 void g_log (const gchar *log_domain,
103 GLogLevelFlags log_level,
104 const gchar *format,
105 ...) G_GNUC_PRINTF (3, 4);
106 GLIB_AVAILABLE_IN_ALL
107 void g_logv (const gchar *log_domain,
108 GLogLevelFlags log_level,
109 const gchar *format,
110 va_list args) G_GNUC_PRINTF(3, 0);
111 GLIB_AVAILABLE_IN_ALL
112 GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
113 GLogLevelFlags fatal_mask);
114 GLIB_AVAILABLE_IN_ALL
115 GLogLevelFlags g_log_set_always_fatal (GLogLevelFlags fatal_mask);
116
117 /* Structured logging mechanism. */
118
119 /**
120 * GLogWriterOutput:
121 * @G_LOG_WRITER_HANDLED: Log writer has handled the log entry.
122 * @G_LOG_WRITER_UNHANDLED: Log writer could not handle the log entry.
123 *
124 * Return values from #GLogWriterFuncs to indicate whether the given log entry
125 * was successfully handled by the writer, or whether there was an error in
126 * handling it (and hence a fallback writer should be used).
127 *
128 * If a #GLogWriterFunc ignores a log entry, it should return
129 * %G_LOG_WRITER_HANDLED.
130 *
131 * Since: 2.50
132 */
133 typedef enum
134 {
135 G_LOG_WRITER_HANDLED = 1,
136 G_LOG_WRITER_UNHANDLED = 0,
137 } GLogWriterOutput;
138
139 /**
140 * GLogField:
141 * @key: field name (UTF-8 string)
142 * @value: field value (arbitrary bytes)
143 * @length: length of @value, in bytes, or -1 if it is nul-terminated
144 *
145 * Structure representing a single field in a structured log entry. See
146 * g_log_structured() for details.
147 *
148 * Log fields may contain arbitrary values, including binary with embedded nul
149 * bytes. If the field contains a string, the string must be UTF-8 encoded and
150 * have a trailing nul byte. Otherwise, @length must be set to a non-negative
151 * value.
152 *
153 * Since: 2.50
154 */
155 typedef struct _GLogField GLogField;
156 struct _GLogField
157 {
158 const gchar *key;
159 gconstpointer value;
160 gssize length;
161 };
162
163 /**
164 * GLogWriterFunc:
165 * @log_level: log level of the message
166 * @fields: (array length=n_fields): fields forming the message
167 * @n_fields: number of @fields
168 * @user_data: user data passed to g_log_set_writer_func()
169 *
170 * Writer function for log entries. A log entry is a collection of one or more
171 * #GLogFields, using the standard [field names from journal
172 * specification](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html).
173 * See g_log_structured() for more information.
174 *
175 * Writer functions must ignore fields which they do not recognise, unless they
176 * can write arbitrary binary output, as field values may be arbitrary binary.
177 *
178 * @log_level is guaranteed to be included in @fields as the `PRIORITY` field,
179 * but is provided separately for convenience of deciding whether or where to
180 * output the log entry.
181 *
182 * Writer functions should return %G_LOG_WRITER_HANDLED if they handled the log
183 * message successfully or if they deliberately ignored it. If there was an
184 * error handling the message (for example, if the writer function is meant to
185 * send messages to a remote logging server and there is a network error), it
186 * should return %G_LOG_WRITER_UNHANDLED. This allows writer functions to be
187 * chained and fall back to simpler handlers in case of failure.
188 *
189 * Returns: %G_LOG_WRITER_HANDLED if the log entry was handled successfully;
190 * %G_LOG_WRITER_UNHANDLED otherwise
191 * Since: 2.50
192 */
193 typedef GLogWriterOutput (*GLogWriterFunc) (GLogLevelFlags log_level,
194 const GLogField *fields,
195 gsize n_fields,
196 gpointer user_data);
197
198 GLIB_AVAILABLE_IN_2_50
199 void g_log_structured (const gchar *log_domain,
200 GLogLevelFlags log_level,
201 ...);
202 GLIB_AVAILABLE_IN_2_50
203 void g_log_structured_array (GLogLevelFlags log_level,
204 const GLogField *fields,
205 gsize n_fields);
206
207 GLIB_AVAILABLE_IN_2_50
208 void g_log_variant (const gchar *log_domain,
209 GLogLevelFlags log_level,
210 GVariant *fields);
211
212 GLIB_AVAILABLE_IN_2_50
213 void g_log_set_writer_func (GLogWriterFunc func,
214 gpointer user_data,
215 GDestroyNotify user_data_free);
216
217 GLIB_AVAILABLE_IN_2_50
218 gboolean g_log_writer_supports_color (gint output_fd);
219 GLIB_AVAILABLE_IN_2_50
220 gboolean g_log_writer_is_journald (gint output_fd);
221
222 GLIB_AVAILABLE_IN_2_50
223 gchar *g_log_writer_format_fields (GLogLevelFlags log_level,
224 const GLogField *fields,
225 gsize n_fields,
226 gboolean use_color);
227
228 GLIB_AVAILABLE_IN_2_50
229 GLogWriterOutput g_log_writer_journald (GLogLevelFlags log_level,
230 const GLogField *fields,
231 gsize n_fields,
232 gpointer user_data);
233 GLIB_AVAILABLE_IN_2_50
234 GLogWriterOutput g_log_writer_standard_streams (GLogLevelFlags log_level,
235 const GLogField *fields,
236 gsize n_fields,
237 gpointer user_data);
238 GLIB_AVAILABLE_IN_2_50
239 GLogWriterOutput g_log_writer_default (GLogLevelFlags log_level,
240 const GLogField *fields,
241 gsize n_fields,
242 gpointer user_data);
243
244 /**
245 * G_DEBUG_HERE:
246 *
247 * A convenience form of g_log_structured(), recommended to be added to
248 * functions when debugging. It prints the current monotonic time and the code
249 * location using %G_STRLOC.
250 *
251 * Since: 2.50
252 */
253 #define G_DEBUG_HERE() \
254 g_log_structured (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
255 "CODE_FILE", __FILE__, \
256 "CODE_LINE", G_STRINGIFY (__LINE__), \
257 "CODE_FUNC", G_STRFUNC, \
258 "MESSAGE", "%" G_GINT64_FORMAT ": %s", \
259 g_get_monotonic_time (), G_STRLOC)
260
261 /* internal */
262 void _g_log_fallback_handler (const gchar *log_domain,
263 GLogLevelFlags log_level,
264 const gchar *message,
265 gpointer unused_data);
266
267 /* Internal functions, used to implement the following macros */
268 GLIB_AVAILABLE_IN_ALL
269 void g_return_if_fail_warning (const char *log_domain,
270 const char *pretty_function,
271 const char *expression) G_ANALYZER_NORETURN;
272 GLIB_AVAILABLE_IN_ALL
273 void g_warn_message (const char *domain,
274 const char *file,
275 int line,
276 const char *func,
277 const char *warnexpr) G_ANALYZER_NORETURN;
278 GLIB_DEPRECATED
279 void g_assert_warning (const char *log_domain,
280 const char *file,
281 const int line,
282 const char *pretty_function,
283 const char *expression) G_GNUC_NORETURN;
284
285 GLIB_AVAILABLE_IN_2_56
286 void g_log_structured_standard (const gchar *log_domain,
287 GLogLevelFlags log_level,
288 const gchar *file,
289 const gchar *line,
290 const gchar *func,
291 const gchar *message_format,
292 ...) G_GNUC_PRINTF (6, 7);
293
294 #ifndef G_LOG_DOMAIN
295 #define G_LOG_DOMAIN ((gchar*) 0)
296 #endif /* G_LOG_DOMAIN */
297
298 #if defined(G_HAVE_ISO_VARARGS) && !G_ANALYZER_ANALYZING
299 #if defined(G_LOG_USE_STRUCTURED) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_56
300 #define g_error(...) G_STMT_START { \
301 g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, \
302 __FILE__, G_STRINGIFY (__LINE__), \
303 G_STRFUNC, __VA_ARGS__); \
304 for (;;) ; \
305 } G_STMT_END
306 #define g_message(...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, \
307 __FILE__, G_STRINGIFY (__LINE__), \
308 G_STRFUNC, __VA_ARGS__)
309 #define g_critical(...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, \
310 __FILE__, G_STRINGIFY (__LINE__), \
311 G_STRFUNC, __VA_ARGS__)
312 #define g_warning(...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, \
313 __FILE__, G_STRINGIFY (__LINE__), \
314 G_STRFUNC, __VA_ARGS__)
315 #define g_info(...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, \
316 __FILE__, G_STRINGIFY (__LINE__), \
317 G_STRFUNC, __VA_ARGS__)
318 #define g_debug(...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
319 __FILE__, G_STRINGIFY (__LINE__), \
320 G_STRFUNC, __VA_ARGS__)
321 #else
322 /* for(;;) ; so that GCC knows that control doesn't go past g_error().
323 * Put space before ending semicolon to avoid C++ build warnings.
324 */
325 #define g_error(...) G_STMT_START { \
326 g_log (G_LOG_DOMAIN, \
327 G_LOG_LEVEL_ERROR, \
328 __VA_ARGS__); \
329 for (;;) ; \
330 } G_STMT_END
331 #define g_message(...) g_log (G_LOG_DOMAIN, \
332 G_LOG_LEVEL_MESSAGE, \
333 __VA_ARGS__)
334 #define g_critical(...) g_log (G_LOG_DOMAIN, \
335 G_LOG_LEVEL_CRITICAL, \
336 __VA_ARGS__)
337 #define g_warning(...) g_log (G_LOG_DOMAIN, \
338 G_LOG_LEVEL_WARNING, \
339 __VA_ARGS__)
340 #define g_info(...) g_log (G_LOG_DOMAIN, \
341 G_LOG_LEVEL_INFO, \
342 __VA_ARGS__)
343 #define g_debug(...) g_log (G_LOG_DOMAIN, \
344 G_LOG_LEVEL_DEBUG, \
345 __VA_ARGS__)
346 #endif
347 #elif defined(G_HAVE_GNUC_VARARGS) && !G_ANALYZER_ANALYZING
348 #if defined(G_LOG_USE_STRUCTURED) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_56
349 #define g_error(format...) G_STMT_START { \
350 g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, \
351 __FILE__, G_STRINGIFY (__LINE__), \
352 G_STRFUNC, format); \
353 for (;;) ; \
354 } G_STMT_END
355 #define g_message(format...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, \
356 __FILE__, G_STRINGIFY (__LINE__), \
357 G_STRFUNC, format)
358 #define g_critical(format...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, \
359 __FILE__, G_STRINGIFY (__LINE__), \
360 G_STRFUNC, format)
361 #define g_warning(format...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, \
362 __FILE__, G_STRINGIFY (__LINE__), \
363 G_STRFUNC, format)
364 #define g_info(format...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, \
365 __FILE__, G_STRINGIFY (__LINE__), \
366 G_STRFUNC, format)
367 #define g_debug(format...) g_log_structured_standard (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
368 __FILE__, G_STRINGIFY (__LINE__), \
369 G_STRFUNC, format)
370 #else
371 #define g_error(format...) G_STMT_START { \
372 g_log (G_LOG_DOMAIN, \
373 G_LOG_LEVEL_ERROR, \
374 format); \
375 for (;;) ; \
376 } G_STMT_END
377
378 #define g_message(format...) g_log (G_LOG_DOMAIN, \
379 G_LOG_LEVEL_MESSAGE, \
380 format)
381 #define g_critical(format...) g_log (G_LOG_DOMAIN, \
382 G_LOG_LEVEL_CRITICAL, \
383 format)
384 #define g_warning(format...) g_log (G_LOG_DOMAIN, \
385 G_LOG_LEVEL_WARNING, \
386 format)
387 #define g_info(format...) g_log (G_LOG_DOMAIN, \
388 G_LOG_LEVEL_INFO, \
389 format)
390 #define g_debug(format...) g_log (G_LOG_DOMAIN, \
391 G_LOG_LEVEL_DEBUG, \
392 format)
393 #endif
394 #else /* no varargs macros */
395 static void g_error (const gchar *format, ...) G_GNUC_NORETURN G_ANALYZER_NORETURN;
396 static void g_critical (const gchar *format, ...) G_ANALYZER_NORETURN;
397
398 static inline void
g_error(const gchar * format,...)399 g_error (const gchar *format,
400 ...)
401 {
402 va_list args;
403 va_start (args, format);
404 g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
405 va_end (args);
406
407 for(;;) ;
408 }
409 static inline void
g_message(const gchar * format,...)410 g_message (const gchar *format,
411 ...)
412 {
413 va_list args;
414 va_start (args, format);
415 g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, args);
416 va_end (args);
417 }
418 static inline void
g_critical(const gchar * format,...)419 g_critical (const gchar *format,
420 ...)
421 {
422 va_list args;
423 va_start (args, format);
424 g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, format, args);
425 va_end (args);
426 }
427 static inline void
g_warning(const gchar * format,...)428 g_warning (const gchar *format,
429 ...)
430 {
431 va_list args;
432 va_start (args, format);
433 g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, args);
434 va_end (args);
435 }
436 static inline void
g_info(const gchar * format,...)437 g_info (const gchar *format,
438 ...)
439 {
440 va_list args;
441 va_start (args, format);
442 g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format, args);
443 va_end (args);
444 }
445 static inline void
g_debug(const gchar * format,...)446 g_debug (const gchar *format,
447 ...)
448 {
449 va_list args;
450 va_start (args, format);
451 g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
452 va_end (args);
453 }
454 #endif /* !__GNUC__ */
455
456 /**
457 * GPrintFunc:
458 * @string: the message to output
459 *
460 * Specifies the type of the print handler functions.
461 * These are called with the complete formatted string to output.
462 */
463 typedef void (*GPrintFunc) (const gchar *string);
464 GLIB_AVAILABLE_IN_ALL
465 void g_print (const gchar *format,
466 ...) G_GNUC_PRINTF (1, 2);
467 GLIB_AVAILABLE_IN_ALL
468 GPrintFunc g_set_print_handler (GPrintFunc func);
469 GLIB_AVAILABLE_IN_ALL
470 void g_printerr (const gchar *format,
471 ...) G_GNUC_PRINTF (1, 2);
472 GLIB_AVAILABLE_IN_ALL
473 GPrintFunc g_set_printerr_handler (GPrintFunc func);
474
475 /**
476 * g_warn_if_reached:
477 *
478 * Logs a warning.
479 *
480 * Since: 2.16
481 */
482 #define g_warn_if_reached() \
483 do { \
484 g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); \
485 } while (0)
486
487 /**
488 * g_warn_if_fail:
489 * @expr: the expression to check
490 *
491 * Logs a warning if the expression is not true.
492 *
493 * Since: 2.16
494 */
495 #define g_warn_if_fail(expr) \
496 do { \
497 if G_LIKELY (expr) ; \
498 else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #expr); \
499 } while (0)
500
501 #ifdef G_DISABLE_CHECKS
502
503 /**
504 * g_return_if_fail:
505 * @expr: the expression to check
506 *
507 * Verifies that the expression @expr, usually representing a precondition,
508 * evaluates to %TRUE. If the function returns a value, use
509 * g_return_val_if_fail() instead.
510 *
511 * If @expr evaluates to %FALSE, the current function should be considered to
512 * have undefined behaviour (a programmer error). The only correct solution
513 * to such an error is to change the module that is calling the current
514 * function, so that it avoids this incorrect call.
515 *
516 * To make this undefined behaviour visible, if @expr evaluates to %FALSE,
517 * the result is usually that a critical message is logged and the current
518 * function returns.
519 *
520 * If `G_DISABLE_CHECKS` is defined then the check is not performed. You
521 * should therefore not depend on any side effects of @expr.
522 *
523 * To debug failure of a g_return_if_fail() check, run the code under a debugger
524 * with `G_DEBUG=fatal-criticals` or `G_DEBUG=fatal-warnings` defined in the
525 * environment (see [Running GLib Applications](glib-running.html)):
526 *
527 * |[
528 * G_DEBUG=fatal-warnings gdb ./my-program
529 * ]|
530 *
531 * Any unrelated failures can be skipped over in
532 * [gdb](https://www.gnu.org/software/gdb/) using the `continue` command.
533 */
534 #define g_return_if_fail(expr) G_STMT_START{ (void)0; }G_STMT_END
535
536 /**
537 * g_return_val_if_fail:
538 * @expr: the expression to check
539 * @val: the value to return from the current function
540 * if the expression is not true
541 *
542 * Verifies that the expression @expr, usually representing a precondition,
543 * evaluates to %TRUE. If the function does not return a value, use
544 * g_return_if_fail() instead.
545 *
546 * If @expr evaluates to %FALSE, the current function should be considered to
547 * have undefined behaviour (a programmer error). The only correct solution
548 * to such an error is to change the module that is calling the current
549 * function, so that it avoids this incorrect call.
550 *
551 * To make this undefined behaviour visible, if @expr evaluates to %FALSE,
552 * the result is usually that a critical message is logged and @val is
553 * returned from the current function.
554 *
555 * If `G_DISABLE_CHECKS` is defined then the check is not performed. You
556 * should therefore not depend on any side effects of @expr.
557 *
558 * See g_return_if_fail() for guidance on how to debug failure of this check.
559 */
560 #define g_return_val_if_fail(expr,val) G_STMT_START{ (void)0; }G_STMT_END
561
562 /**
563 * g_return_if_reached:
564 *
565 * Logs a critical message and returns from the current function.
566 * This can only be used in functions which do not return a value.
567 *
568 * See g_return_if_fail() for guidance on how to debug failure of this check.
569 */
570 #define g_return_if_reached() G_STMT_START{ return; }G_STMT_END
571
572 /**
573 * g_return_val_if_reached:
574 * @val: the value to return from the current function
575 *
576 * Logs a critical message and returns @val.
577 *
578 * See g_return_if_fail() for guidance on how to debug failure of this check.
579 */
580 #define g_return_val_if_reached(val) G_STMT_START{ return (val); }G_STMT_END
581
582 #else /* !G_DISABLE_CHECKS */
583
584 #define g_return_if_fail(expr) \
585 G_STMT_START { \
586 if (G_LIKELY (expr)) \
587 { } \
588 else \
589 { \
590 g_return_if_fail_warning (G_LOG_DOMAIN, \
591 G_STRFUNC, \
592 #expr); \
593 return; \
594 } \
595 } G_STMT_END
596
597 #define g_return_val_if_fail(expr, val) \
598 G_STMT_START { \
599 if (G_LIKELY (expr)) \
600 { } \
601 else \
602 { \
603 g_return_if_fail_warning (G_LOG_DOMAIN, \
604 G_STRFUNC, \
605 #expr); \
606 return (val); \
607 } \
608 } G_STMT_END
609
610 #define g_return_if_reached() \
611 G_STMT_START { \
612 g_log (G_LOG_DOMAIN, \
613 G_LOG_LEVEL_CRITICAL, \
614 "file %s: line %d (%s): should not be reached", \
615 __FILE__, \
616 __LINE__, \
617 G_STRFUNC); \
618 return; \
619 } G_STMT_END
620
621 #define g_return_val_if_reached(val) \
622 G_STMT_START { \
623 g_log (G_LOG_DOMAIN, \
624 G_LOG_LEVEL_CRITICAL, \
625 "file %s: line %d (%s): should not be reached", \
626 __FILE__, \
627 __LINE__, \
628 G_STRFUNC); \
629 return (val); \
630 } G_STMT_END
631
632 #endif /* !G_DISABLE_CHECKS */
633
634 G_END_DECLS
635
636 #endif /* __G_MESSAGES_H__ */
637