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 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, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 */
19
20/*
21 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
22 * file for a list of people on the GLib Team.  See the ChangeLog
23 * files for a list of changes.  These files are distributed with
24 * GLib at ftp://ftp.gtk.org/pub/gtk/.
25 */
26
27#if defined(G_DISABLE_SINGLE_INCLUDES) && !defined (__GLIB_H_INSIDE__) && !defined (GLIB_COMPILATION)
28#error "Only <glib.h> can be included directly."
29#endif
30
31#ifndef __G_MESSAGES_H__
32#define __G_MESSAGES_H__
33
34#include <stdarg.h>
35#include <glib/gtypes.h>
36#include <glib/gmacros.h>
37
38/* Suppress warnings when GCC is in -pedantic mode and not -std=c99
39 */
40#if (__GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
41#pragma GCC system_header
42#endif
43
44G_BEGIN_DECLS
45
46/* calculate a string size, guaranteed to fit format + args.
47 */
48gsize	g_printf_string_upper_bound (const gchar* format,
49				     va_list	  args);
50
51/* Log level shift offset for user defined
52 * log levels (0-7 are used by GLib).
53 */
54#define G_LOG_LEVEL_USER_SHIFT  (8)
55
56/* Glib log levels and flags.
57 */
58typedef enum
59{
60  /* log flags */
61  G_LOG_FLAG_RECURSION          = 1 << 0,
62  G_LOG_FLAG_FATAL              = 1 << 1,
63
64  /* GLib log levels */
65  G_LOG_LEVEL_ERROR             = 1 << 2,       /* always fatal */
66  G_LOG_LEVEL_CRITICAL          = 1 << 3,
67  G_LOG_LEVEL_WARNING           = 1 << 4,
68  G_LOG_LEVEL_MESSAGE           = 1 << 5,
69  G_LOG_LEVEL_INFO              = 1 << 6,
70  G_LOG_LEVEL_DEBUG             = 1 << 7,
71
72  G_LOG_LEVEL_MASK              = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
73} GLogLevelFlags;
74
75/* GLib log levels that are considered fatal by default */
76#define G_LOG_FATAL_MASK        (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR)
77
78typedef void            (*GLogFunc)             (const gchar   *log_domain,
79                                                 GLogLevelFlags log_level,
80                                                 const gchar   *message,
81                                                 gpointer       user_data);
82
83/* Logging mechanism
84 */
85guint           g_log_set_handler       (const gchar    *log_domain,
86                                         GLogLevelFlags  log_levels,
87                                         GLogFunc        log_func,
88                                         gpointer        user_data);
89void            g_log_remove_handler    (const gchar    *log_domain,
90                                         guint           handler_id);
91void            g_log_default_handler   (const gchar    *log_domain,
92                                         GLogLevelFlags  log_level,
93                                         const gchar    *message,
94                                         gpointer        unused_data);
95GLogFunc        g_log_set_default_handler (GLogFunc      log_func,
96					   gpointer      user_data);
97void            g_log                   (const gchar    *log_domain,
98                                         GLogLevelFlags  log_level,
99                                         const gchar    *format,
100                                         ...) G_GNUC_PRINTF (3, 4);
101void            g_logv                  (const gchar    *log_domain,
102                                         GLogLevelFlags  log_level,
103                                         const gchar    *format,
104                                         va_list         args);
105GLogLevelFlags  g_log_set_fatal_mask    (const gchar    *log_domain,
106                                         GLogLevelFlags  fatal_mask);
107GLogLevelFlags  g_log_set_always_fatal  (GLogLevelFlags  fatal_mask);
108
109/* internal */
110G_GNUC_INTERNAL void	_g_log_fallback_handler	(const gchar   *log_domain,
111						 GLogLevelFlags log_level,
112						 const gchar   *message,
113						 gpointer       unused_data);
114
115/* Internal functions, used to implement the following macros */
116void g_return_if_fail_warning (const char *log_domain,
117			       const char *pretty_function,
118			       const char *expression);
119void g_warn_message           (const char     *domain,
120                               const char     *file,
121                               int             line,
122                               const char     *func,
123                               const char     *warnexpr);
124#ifndef G_DISABLE_DEPRECATED
125void g_assert_warning         (const char *log_domain,
126			       const char *file,
127			       const int   line,
128		               const char *pretty_function,
129		               const char *expression) G_GNUC_NORETURN;
130#endif /* !G_DISABLE_DEPRECATED */
131
132
133#ifndef G_LOG_DOMAIN
134#define G_LOG_DOMAIN    ((gchar*) 0)
135#endif  /* G_LOG_DOMAIN */
136#ifdef G_HAVE_ISO_VARARGS
137/* for(;;); so that GCC knows that control doesn't go past g_error() */
138#define g_error(...)  G_STMT_START {                 \
139                        g_log (G_LOG_DOMAIN,         \
140                               G_LOG_LEVEL_ERROR,    \
141                               __VA_ARGS__);         \
142                        for (;;);                    \
143                      } G_STMT_END
144
145#define g_message(...)  g_log (G_LOG_DOMAIN,         \
146                               G_LOG_LEVEL_MESSAGE,  \
147                               __VA_ARGS__)
148#define g_critical(...) g_log (G_LOG_DOMAIN,         \
149                               G_LOG_LEVEL_CRITICAL, \
150                               __VA_ARGS__)
151#define g_warning(...)  g_log (G_LOG_DOMAIN,         \
152                               G_LOG_LEVEL_WARNING,  \
153                               __VA_ARGS__)
154#define g_debug(...)    g_log (G_LOG_DOMAIN,         \
155                               G_LOG_LEVEL_DEBUG,    \
156                               __VA_ARGS__)
157#elif defined(G_HAVE_GNUC_VARARGS)
158#define g_error(format...)    G_STMT_START {                 \
159                                g_log (G_LOG_DOMAIN,         \
160                                       G_LOG_LEVEL_ERROR,    \
161                                       format);              \
162                                for (;;);                    \
163                              } G_STMT_END
164
165#define g_message(format...)    g_log (G_LOG_DOMAIN,         \
166                                       G_LOG_LEVEL_MESSAGE,  \
167                                       format)
168#define g_critical(format...)   g_log (G_LOG_DOMAIN,         \
169                                       G_LOG_LEVEL_CRITICAL, \
170                                       format)
171#define g_warning(format...)    g_log (G_LOG_DOMAIN,         \
172                                       G_LOG_LEVEL_WARNING,  \
173                                       format)
174#define g_debug(format...)      g_log (G_LOG_DOMAIN,         \
175                                       G_LOG_LEVEL_DEBUG,    \
176                                       format)
177#else   /* no varargs macros */
178static void
179g_error (const gchar *format,
180         ...)
181{
182  va_list args;
183  va_start (args, format);
184  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
185  va_end (args);
186
187  for(;;);
188}
189static void
190g_message (const gchar *format,
191           ...)
192{
193  va_list args;
194  va_start (args, format);
195  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, format, args);
196  va_end (args);
197}
198static void
199g_critical (const gchar *format,
200            ...)
201{
202  va_list args;
203  va_start (args, format);
204  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, format, args);
205  va_end (args);
206}
207static void
208g_warning (const gchar *format,
209           ...)
210{
211  va_list args;
212  va_start (args, format);
213  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, format, args);
214  va_end (args);
215}
216static void
217g_debug (const gchar *format,
218         ...)
219{
220  va_list args;
221  va_start (args, format);
222  g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format, args);
223  va_end (args);
224}
225#endif  /* !__GNUC__ */
226
227typedef void    (*GPrintFunc)           (const gchar    *string);
228void            g_print                 (const gchar    *format,
229                                         ...) G_GNUC_PRINTF (1, 2);
230GPrintFunc      g_set_print_handler     (GPrintFunc      func);
231void            g_printerr              (const gchar    *format,
232                                         ...) G_GNUC_PRINTF (1, 2);
233GPrintFunc      g_set_printerr_handler  (GPrintFunc      func);
234
235
236/* Provide macros for graceful error handling.
237 * The "return" macros will return from the current function.
238 * Two different definitions are given for the macros in
239 * order to support gcc's __PRETTY_FUNCTION__ capability.
240 */
241
242#define g_warn_if_reached()     do { g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, NULL); } while (0)
243#define g_warn_if_fail(expr)    do { if G_LIKELY (expr) ; else \
244                                       g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #expr); } while (0)
245
246#ifdef G_DISABLE_CHECKS
247
248#define g_return_if_fail(expr)			G_STMT_START{ (void)0; }G_STMT_END
249#define g_return_val_if_fail(expr,val)		G_STMT_START{ (void)0; }G_STMT_END
250#define g_return_if_reached()			G_STMT_START{ return; }G_STMT_END
251#define g_return_val_if_reached(val)		G_STMT_START{ return (val); }G_STMT_END
252
253#else /* !G_DISABLE_CHECKS */
254
255#ifdef __GNUC__
256
257#define g_return_if_fail(expr)		G_STMT_START{			\
258     if G_LIKELY(expr) { } else       					\
259       {								\
260	 g_return_if_fail_warning (G_LOG_DOMAIN,			\
261		                   __PRETTY_FUNCTION__,		        \
262		                   #expr);				\
263	 return;							\
264       };				}G_STMT_END
265
266#define g_return_val_if_fail(expr,val)	G_STMT_START{			\
267     if G_LIKELY(expr) { } else						\
268       {								\
269	 g_return_if_fail_warning (G_LOG_DOMAIN,			\
270		                   __PRETTY_FUNCTION__,		        \
271		                   #expr);				\
272	 return (val);							\
273       };				}G_STMT_END
274
275#define g_return_if_reached()		G_STMT_START{			\
276     g_log (G_LOG_DOMAIN,						\
277	    G_LOG_LEVEL_CRITICAL,					\
278	    "file %s: line %d (%s): should not be reached",		\
279	    __FILE__,							\
280	    __LINE__,							\
281	    __PRETTY_FUNCTION__);					\
282     return;				}G_STMT_END
283
284#define g_return_val_if_reached(val)	G_STMT_START{			\
285     g_log (G_LOG_DOMAIN,						\
286	    G_LOG_LEVEL_CRITICAL,					\
287	    "file %s: line %d (%s): should not be reached",		\
288	    __FILE__,							\
289	    __LINE__,							\
290	    __PRETTY_FUNCTION__);					\
291     return (val);			}G_STMT_END
292
293#else /* !__GNUC__ */
294
295#define g_return_if_fail(expr)		G_STMT_START{		\
296     if (expr) { } else						\
297       {							\
298	 g_log (G_LOG_DOMAIN,					\
299		G_LOG_LEVEL_CRITICAL,				\
300		"file %s: line %d: assertion `%s' failed",	\
301		__FILE__,					\
302		__LINE__,					\
303		#expr);						\
304	 return;						\
305       };				}G_STMT_END
306
307#define g_return_val_if_fail(expr, val)	G_STMT_START{		\
308     if (expr) { } else						\
309       {							\
310	 g_log (G_LOG_DOMAIN,					\
311		G_LOG_LEVEL_CRITICAL,				\
312		"file %s: line %d: assertion `%s' failed",	\
313		__FILE__,					\
314		__LINE__,					\
315		#expr);						\
316	 return (val);						\
317       };				}G_STMT_END
318
319#define g_return_if_reached()		G_STMT_START{		\
320     g_log (G_LOG_DOMAIN,					\
321	    G_LOG_LEVEL_CRITICAL,				\
322	    "file %s: line %d: should not be reached",		\
323	    __FILE__,						\
324	    __LINE__);						\
325     return;				}G_STMT_END
326
327#define g_return_val_if_reached(val)	G_STMT_START{		\
328     g_log (G_LOG_DOMAIN,					\
329	    G_LOG_LEVEL_CRITICAL,				\
330	    "file %s: line %d: should not be reached",		\
331	    __FILE__,						\
332	    __LINE__);						\
333     return (val);			}G_STMT_END
334
335#endif /* !__GNUC__ */
336
337#endif /* !G_DISABLE_CHECKS */
338
339G_END_DECLS
340
341#endif /* __G_MESSAGES_H__ */
342