eglib/src/goutput.c

   1 /*
   2  * Output and debugging functions
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@novell.com)
   6  *
   7  * (C) 2006 Novell, Inc.
   8  * Copyright 2011 Xamarin Inc.
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining
  11  * a copy of this software and associated documentation files (the
  12  * "Software"), to deal in the Software without restriction, including
  13  * without limitation the rights to use, copy, modify, merge, publish,
  14  * distribute, sublicense, and/or sell copies of the Software, and to
  15  * permit persons to whom the Software is furnished to do so, subject to
  16  * the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be
  19  * included in all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  */
  29 #include <config.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <glib.h>
  33
  34 #include "vasprintf.h"
  35
  36 /* The current fatal levels, error is always fatal */
  37 static GLogLevelFlags fatal = G_LOG_LEVEL_ERROR;
  38 static GLogFunc default_log_func;
  39 static gpointer default_log_func_user_data;
  40 static GPrintFunc stdout_handler, stderr_handler;
  41
  42 static void default_stdout_handler (const gchar *string);
  43 static void default_stderr_handler (const gchar *string);
  44
  45 void
  46 g_print (const gchar *format, ...)
  47 {
  48         char *msg;
  49         va_list args;
  50
  51         va_start (args, format);
  52         if (vasprintf (&msg, format, args) < 0)
  53                 return;
  54         va_end (args);
  55
  56         if (!stdout_handler)
  57                 stdout_handler = default_stdout_handler;
  58
  59         stdout_handler (msg);
  60         free (msg);
  61 }
  62
  63 void
  64 g_printerr (const gchar *format, ...)
  65 {
  66         char *msg;
  67         va_list args;
  68
  69         va_start (args, format);
  70         if (vasprintf (&msg, format, args) < 0)
  71                 return;
  72         va_end (args);
  73
  74         if (!stderr_handler)
  75                 stderr_handler = default_stderr_handler;
  76
  77         stderr_handler (msg);
  78         free (msg);
  79 }
  80
  81 GLogLevelFlags
  82 g_log_set_always_fatal (GLogLevelFlags fatal_mask)
  83 {
  84         GLogLevelFlags old_fatal = fatal;
  85
  86         fatal |= fatal_mask;
  87
  88         return old_fatal;
  89 }
  90
  91 GLogLevelFlags
  92 g_log_set_fatal_mask (const gchar *log_domain, GLogLevelFlags fatal_mask)
  93 {
  94         /*
  95          * Mono does not use a G_LOG_DOMAIN currently, so we just assume things are fatal
  96          * if we decide to set G_LOG_DOMAIN (we probably should) we should implement
  97          * this.
  98          */
  99         return fatal_mask;
 100 }
 101
 102 void
 103 g_logv (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, va_list args)
 104 {
 105         char *msg;
 106
 107         if (!default_log_func)
 108                 default_log_func = g_log_default_handler;
 109
 110         if (vasprintf (&msg, format, args) < 0)
 111                 return;
 112
 113         default_log_func (log_domain, log_level, msg, default_log_func_user_data);
 114         free (msg);
 115 }
 116
 117 void
 118 g_log (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, ...)
 119 {
 120         va_list args;
 121
 122         va_start (args, format);
 123         g_logv (log_domain, log_level, format, args);
 124         va_end (args);
 125 }
 126
 127 void
 128 g_assertion_message (const gchar *format, ...)
 129 {
 130         va_list args;
 131
 132         va_start (args, format);
 133         g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
 134         va_end (args);
 135         exit (0);
 136 }
 137
 138
 139 #if PLATFORM_ANDROID
 140 #include <android/log.h>
 141
 142 static android_LogPriority
 143 to_android_priority (GLogLevelFlags log_level)
 144 {
 145         switch (log_level & G_LOG_LEVEL_MASK)
 146         {
 147                 case G_LOG_LEVEL_ERROR:     return ANDROID_LOG_FATAL;
 148                 case G_LOG_LEVEL_CRITICAL:  return ANDROID_LOG_ERROR;
 149                 case G_LOG_LEVEL_WARNING:   return ANDROID_LOG_WARN;
 150                 case G_LOG_LEVEL_MESSAGE:   return ANDROID_LOG_INFO;
 151                 case G_LOG_LEVEL_INFO:      return ANDROID_LOG_DEBUG;
 152                 case G_LOG_LEVEL_DEBUG:     return ANDROID_LOG_VERBOSE;
 153         }
 154         return ANDROID_LOG_UNKNOWN;
 155 }
 156
 157 void
 158 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 159 {
 160         __android_log_write (to_android_priority (log_level), log_domain, message);
 161         if (log_level & fatal)
 162                 abort ();
 163 }
 164
 165 static void
 166 default_stdout_handler (const gchar *message)
 167 {
 168         /* TODO: provide a proper app name */
 169         __android_log_write (ANDROID_LOG_ERROR, "mono", message);
 170 }
 171
 172 static void
 173 default_stderr_handler (const gchar *message)
 174 {
 175         /* TODO: provide a proper app name */
 176         __android_log_write (ANDROID_LOG_ERROR, "mono", message);
 177 }
 178
 179
 180 #elif defined(HOST_IOS)
 181 #include <asl.h>
 182
 183 static int
 184 to_asl_priority (GLogLevelFlags log_level)
 185 {
 186         switch (log_level & G_LOG_LEVEL_MASK)
 187         {
 188                 case G_LOG_LEVEL_ERROR:     return ASL_LEVEL_CRIT;
 189                 case G_LOG_LEVEL_CRITICAL:  return ASL_LEVEL_ERR;
 190                 case G_LOG_LEVEL_WARNING:   return ASL_LEVEL_WARNING;
 191                 case G_LOG_LEVEL_MESSAGE:   return ASL_LEVEL_NOTICE;
 192                 case G_LOG_LEVEL_INFO:      return ASL_LEVEL_INFO;
 193                 case G_LOG_LEVEL_DEBUG:     return ASL_LEVEL_DEBUG;
 194         }
 195         return ASL_LEVEL_ERR;
 196 }
 197
 198 void
 199 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 200 {
 201         asl_log (NULL, NULL, to_asl_priority (log_level), "%s", message);
 202         if (log_level & fatal)
 203                 abort ();
 204 }
 205
 206 static void
 207 default_stdout_handler (const gchar *message)
 208 {
 209         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 210 }
 211
 212 static void
 213 default_stderr_handler (const gchar *message)
 214 {
 215         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 216 }
 217
 218 #else
 219
 220 void
 221 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 222 {
 223         FILE *target = stdout;
 224
 225         fprintf (target, "%s%s%s\n",
 226                 log_domain != NULL ? log_domain : "",
 227                 log_domain != NULL ? ": " : "",
 228                 message);
 229
 230         if (log_level & fatal) {
 231                 fflush (stdout);
 232                 fflush (stderr);
 233                 abort ();
 234         }
 235 }
 236
 237 static void
 238 default_stdout_handler (const gchar *string)
 239 {
 240         fprintf (stdout, "%s", string);
 241 }
 242
 243 static void
 244 default_stderr_handler (const gchar *string)
 245 {
 246         fprintf (stderr, "%s", string);
 247 }
 248
 249 #endif
 250
 251 GLogFunc
 252 g_log_set_default_handler (GLogFunc log_func, gpointer user_data)
 253 {
 254         GLogFunc old = default_log_func;
 255         default_log_func = log_func;
 256         default_log_func_user_data = user_data;
 257         return old;
 258 }
 259
 260 GPrintFunc
 261 g_set_print_handler (GPrintFunc func)
 262 {
 263         GPrintFunc old = stdout_handler;
 264         stdout_handler = func;
 265         return old;
 266 }
 267
 268 GPrintFunc
 269 g_set_printerr_handler (GPrintFunc func)
 270 {
 271         GPrintFunc old = stderr_handler;
 272         stderr_handler = func;
 273         return old;
 274 }
 275