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
37G_BEGIN_DECLS
38
39/* calculate a string size, guaranteed to fit format + args.
40 */
41GLIB_AVAILABLE_IN_ALL
42gsize 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 */
52typedef 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
72typedef void (*GLogFunc) (const gchar *log_domain,
73 GLogLevelFlags log_level,
74 const gchar *message,
75 gpointer user_data);
76
77/* Logging mechanism
78 */
79GLIB_AVAILABLE_IN_ALL
80guint g_log_set_handler (const gchar *log_domain,
81 GLogLevelFlags log_levels,
82 GLogFunc log_func,
83 gpointer user_data);
84GLIB_AVAILABLE_IN_2_46
85guint g_log_set_handler_full (const gchar *log_domain,
86 GLogLevelFlags log_levels,
87 GLogFunc log_func,
88 gpointer user_data,
89 GDestroyNotify destroy);
90GLIB_AVAILABLE_IN_ALL
91void g_log_remove_handler (const gchar *log_domain,
92 guint handler_id);
93GLIB_AVAILABLE_IN_ALL
94void g_log_default_handler (const gchar *log_domain,
95 GLogLevelFlags log_level,
96 const gchar *message,
97 gpointer unused_data);
98GLIB_AVAILABLE_IN_ALL
99GLogFunc g_log_set_default_handler (GLogFunc log_func,
100 gpointer user_data);
101GLIB_AVAILABLE_IN_ALL
102void g_log (const gchar *log_domain,
103 GLogLevelFlags log_level,
104 const gchar *format,
105 ...) G_GNUC_PRINTF (3, 4);
106GLIB_AVAILABLE_IN_ALL
107void g_logv (const gchar *log_domain,
108 GLogLevelFlags log_level,
109 const gchar *format,
110 va_list args) G_GNUC_PRINTF(3, 0);
111GLIB_AVAILABLE_IN_ALL
112GLogLevelFlags g_log_set_fatal_mask (const gchar *log_domain,
113 GLogLevelFlags fatal_mask);
114GLIB_AVAILABLE_IN_ALL
115GLogLevelFlags 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 */
133typedef 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 */
155typedef struct _GLogField GLogField;
156struct _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 */
193typedef GLogWriterOutput (*GLogWriterFunc) (GLogLevelFlags log_level,
194 const GLogField *fields,
195 gsize n_fields,
196 gpointer user_data);
197
198GLIB_AVAILABLE_IN_2_50
199void g_log_structured (const gchar *log_domain,
200 GLogLevelFlags log_level,
201 ...);
202GLIB_AVAILABLE_IN_2_50
203void g_log_structured_array (GLogLevelFlags log_level,
204 const GLogField *fields,
205 gsize n_fields);
206
207GLIB_AVAILABLE_IN_2_50
208void g_log_variant (const gchar *log_domain,
209 GLogLevelFlags log_level,
210 GVariant *fields);
211
212GLIB_AVAILABLE_IN_2_50
213void g_log_set_writer_func (GLogWriterFunc func,
214 gpointer user_data,
215 GDestroyNotify user_data_free);
216
217GLIB_AVAILABLE_IN_2_50
218gboolean g_log_writer_supports_color (gint output_fd);
219GLIB_AVAILABLE_IN_2_50
220gboolean g_log_writer_is_journald (gint output_fd);
221
222GLIB_AVAILABLE_IN_2_50
223gchar *g_log_writer_format_fields (GLogLevelFlags log_level,
224 const GLogField *fields,
225 gsize n_fields,
226 gboolean use_color);
227
228GLIB_AVAILABLE_IN_2_50
229GLogWriterOutput g_log_writer_journald (GLogLevelFlags log_level,
230 const GLogField *fields,
231 gsize n_fields,
232 gpointer user_data);
233GLIB_AVAILABLE_IN_2_50
234GLogWriterOutput g_log_writer_standard_streams (GLogLevelFlags log_level,
235 const GLogField *fields,
236 gsize n_fields,
237 gpointer user_data);
238GLIB_AVAILABLE_IN_2_50
239GLogWriterOutput 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 */
262void _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 */
268GLIB_AVAILABLE_IN_ALL
269void g_return_if_fail_warning (const char *log_domain,
270 const char *pretty_function,
271 const char *expression) G_ANALYZER_NORETURN;
272GLIB_AVAILABLE_IN_ALL
273void g_warn_message (const char *domain,
274 const char *file,
275 int line,
276 const char *func,
277 const char *warnexpr) G_ANALYZER_NORETURN;
278GLIB_DEPRECATED
279void 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
285GLIB_AVAILABLE_IN_2_56
286void 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#ifdef G_LOG_USE_STRUCTURED
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#ifdef G_LOG_USE_STRUCTURED
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 */
395static void g_error (const gchar *format, ...) G_GNUC_NORETURN G_ANALYZER_NORETURN;
396static void g_critical (const gchar *format, ...) G_ANALYZER_NORETURN;
397
398static inline void
399g_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}
409static inline void
410g_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}
418static inline void
419g_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}
427static inline void
428g_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}
436static inline void
437g_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}
445static inline void
446g_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 */
463typedef void (*GPrintFunc) (const gchar *string);
464GLIB_AVAILABLE_IN_ALL
465void g_print (const gchar *format,
466 ...) G_GNUC_PRINTF (1, 2);
467GLIB_AVAILABLE_IN_ALL
468GPrintFunc g_set_print_handler (GPrintFunc func);
469GLIB_AVAILABLE_IN_ALL
470void g_printerr (const gchar *format,
471 ...) G_GNUC_PRINTF (1, 2);
472GLIB_AVAILABLE_IN_ALL
473GPrintFunc 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
634G_END_DECLS
635
636#endif /* __G_MESSAGES_H__ */
637