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 }
 136
 137
 138 #if PLATFORM_ANDROID
 139 #include <android/log.h>
 140
 141 static android_LogPriority
 142 to_android_priority (GLogLevelFlags log_level)
 143 {
 144         switch (log_level & G_LOG_LEVEL_MASK)
 145         {
 146                 case G_LOG_LEVEL_ERROR:     return ANDROID_LOG_FATAL;
 147                 case G_LOG_LEVEL_CRITICAL:  return ANDROID_LOG_ERROR;
 148                 case G_LOG_LEVEL_WARNING:   return ANDROID_LOG_WARN;
 149                 case G_LOG_LEVEL_MESSAGE:   return ANDROID_LOG_INFO;
 150                 case G_LOG_LEVEL_INFO:      return ANDROID_LOG_DEBUG;
 151                 case G_LOG_LEVEL_DEBUG:     return ANDROID_LOG_VERBOSE;
 152         }
 153         return ANDROID_LOG_UNKNOWN;
 154 }
 155
 156 void
 157 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 158 {
 159         __android_log_write (to_android_priority (log_level), log_domain, message);
 160         if (log_level & fatal)
 161                 abort ();
 162 }
 163
 164 static void
 165 default_stdout_handler (const gchar *message)
 166 {
 167         /* TODO: provide a proper app name */
 168         __android_log_write (ANDROID_LOG_ERROR, "mono", message);
 169 }
 170
 171 static void
 172 default_stderr_handler (const gchar *message)
 173 {
 174         /* TODO: provide a proper app name */
 175         __android_log_write (ANDROID_LOG_ERROR, "mono", message);
 176 }
 177
 178
 179 #elif defined(HOST_IOS)
 180 #include <asl.h>
 181
 182 static int
 183 to_asl_priority (GLogLevelFlags log_level)
 184 {
 185         switch (log_level & G_LOG_LEVEL_MASK)
 186         {
 187                 case G_LOG_LEVEL_ERROR:     return ASL_LEVEL_CRIT;
 188                 case G_LOG_LEVEL_CRITICAL:  return ASL_LEVEL_ERR;
 189                 case G_LOG_LEVEL_WARNING:   return ASL_LEVEL_WARNING;
 190                 case G_LOG_LEVEL_MESSAGE:   return ASL_LEVEL_NOTICE;
 191                 case G_LOG_LEVEL_INFO:      return ASL_LEVEL_INFO;
 192                 case G_LOG_LEVEL_DEBUG:     return ASL_LEVEL_DEBUG;
 193         }
 194         return ASL_LEVEL_ERR;
 195 }
 196
 197 void
 198 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 199 {
 200         asl_log (NULL, NULL, to_asl_priority (log_level), "%s", message);
 201         if (log_level & fatal)
 202                 abort ();
 203 }
 204
 205 static void
 206 default_stdout_handler (const gchar *message)
 207 {
 208         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 209 }
 210
 211 static void
 212 default_stderr_handler (const gchar *message)
 213 {
 214         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 215 }
 216
 217 #else
 218
 219 void
 220 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 221 {
 222         FILE *target = stdout;
 223
 224         fprintf (target, "%s%s%s\n",
 225                 log_domain != NULL ? log_domain : "",
 226                 log_domain != NULL ? ": " : "",
 227                 message);
 228
 229         if (log_level & fatal) {
 230                 fflush (stdout);
 231                 fflush (stderr);
 232                 abort ();
 233         }
 234 }
 235
 236 static void
 237 default_stdout_handler (const gchar *string)
 238 {
 239         fprintf (stdout, "%s", string);
 240 }
 241
 242 static void
 243 default_stderr_handler (const gchar *string)
 244 {
 245         fprintf (stderr, "%s", string);
 246 }
 247
 248 #endif
 249
 250 GLogFunc
 251 g_log_set_default_handler (GLogFunc log_func, gpointer user_data)
 252 {
 253         GLogFunc old = default_log_func;
 254         default_log_func = log_func;
 255         default_log_func_user_data = user_data;
 256         return old;
 257 }
 258
 259 GPrintFunc
 260 g_set_print_handler (GPrintFunc func)
 261 {
 262         GPrintFunc old = stdout_handler;
 263         stdout_handler = func;
 264         return old;
 265 }
 266
 267 GPrintFunc
 268 g_set_printerr_handler (GPrintFunc func)
 269 {
 270         GPrintFunc old = stderr_handler;
 271         stderr_handler = func;
 272         return old;
 273 }
 274