mono/eglib/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 /* The current fatal levels, error is always fatal */
  35 static GLogLevelFlags fatal = G_LOG_LEVEL_ERROR;
  36 static GLogFunc default_log_func;
  37 static gpointer default_log_func_user_data;
  38 static GPrintFunc stdout_handler, stderr_handler;
  39
  40 static void default_stdout_handler (const gchar *string);
  41 static void default_stderr_handler (const gchar *string);
  42
  43 static GAbortFunc internal_abort_func;
  44
  45 void
  46 g_assertion_disable_global (GAbortFunc abort_func)
  47 {
  48         internal_abort_func = abort_func;
  49 }
  50
  51 void
  52 g_assert_abort (void)
  53 {
  54         if (internal_abort_func)
  55                 internal_abort_func ();
  56         else
  57                 abort ();
  58 }
  59
  60 void
  61 g_printv (const gchar *format, va_list args)
  62 {
  63         char *msg;
  64
  65         if (g_vasprintf (&msg, format, args) < 0)
  66                 return;
  67
  68         if (!stdout_handler)
  69                 stdout_handler = default_stdout_handler;
  70
  71         stdout_handler (msg);
  72         g_free (msg);
  73 }
  74
  75 void
  76 g_print (const gchar *format, ...)
  77 {
  78         va_list args;
  79         va_start (args, format);
  80         g_printv (format, args);
  81         va_end (args);
  82 }
  83
  84 void
  85 g_printerr (const gchar *format, ...)
  86 {
  87         char *msg;
  88         va_list args;
  89
  90         va_start (args, format);
  91         if (g_vasprintf (&msg, format, args) < 0) {
  92                 va_end (args);
  93                 return;
  94         }
  95         va_end (args);
  96
  97         if (!stderr_handler)
  98                 stderr_handler = default_stderr_handler;
  99
 100         stderr_handler (msg);
 101         g_free (msg);
 102 }
 103
 104 GLogLevelFlags
 105 g_log_set_always_fatal (GLogLevelFlags fatal_mask)
 106 {
 107         GLogLevelFlags old_fatal = fatal;
 108
 109         fatal |= fatal_mask;
 110
 111         return old_fatal;
 112 }
 113
 114 GLogLevelFlags
 115 g_log_set_fatal_mask (const gchar *log_domain, GLogLevelFlags fatal_mask)
 116 {
 117         /*
 118          * Mono does not use a G_LOG_DOMAIN currently, so we just assume things are fatal
 119          * if we decide to set G_LOG_DOMAIN (we probably should) we should implement
 120          * this.
 121          */
 122         return fatal_mask;
 123 }
 124
 125 #define g_logstr monoeg_g_logstr
 126 #define g_logv_nofree monoeg_g_logv_nofree
 127
 128 static void
 129 g_logstr (const gchar *log_domain, GLogLevelFlags log_level, const gchar *msg)
 130 {
 131         if (!default_log_func)
 132                 default_log_func = g_log_default_handler;
 133
 134         default_log_func (log_domain, log_level, msg, default_log_func_user_data);
 135 }
 136
 137 static gchar*
 138 g_logv_nofree (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, va_list args)
 139 {
 140         char *msg;
 141
 142         if (internal_abort_func) {
 143                 g_async_safe_vprintf (format, args);
 144                 return NULL;
 145         } else if (g_vasprintf (&msg, format, args) < 0) {
 146                 return NULL;
 147         }
 148
 149         g_logstr (log_domain, log_level, msg);
 150         return msg;
 151 }
 152
 153 void
 154 g_logv (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, va_list args)
 155 {
 156         g_free (g_logv_nofree (log_domain, log_level, format, args));
 157 }
 158
 159 void
 160 g_log (const gchar *log_domain, GLogLevelFlags log_level, const gchar *format, ...)
 161 {
 162         va_list args;
 163
 164         va_start (args, format);
 165         g_logv (log_domain, log_level, format, args);
 166         va_end (args);
 167 }
 168
 169 static char *failure_assertion = NULL;
 170
 171 const char *
 172 g_get_assertion_message (void)
 173 {
 174         return failure_assertion;
 175 }
 176
 177 void
 178 g_assertion_message (const gchar *format, ...)
 179 {
 180         va_list args;
 181
 182         va_start (args, format);
 183
 184         failure_assertion = g_logv_nofree (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR, format, args);
 185
 186         va_end (args);
 187         exit (0);
 188 }
 189
 190 #if HOST_ANDROID
 191 #include <android/log.h>
 192
 193 static android_LogPriority
 194 to_android_priority (GLogLevelFlags log_level)
 195 {
 196         switch (log_level & G_LOG_LEVEL_MASK)
 197         {
 198                 case G_LOG_LEVEL_ERROR:     return ANDROID_LOG_FATAL;
 199                 case G_LOG_LEVEL_CRITICAL:  return ANDROID_LOG_ERROR;
 200                 case G_LOG_LEVEL_WARNING:   return ANDROID_LOG_WARN;
 201                 case G_LOG_LEVEL_MESSAGE:   return ANDROID_LOG_INFO;
 202                 case G_LOG_LEVEL_INFO:      return ANDROID_LOG_DEBUG;
 203                 case G_LOG_LEVEL_DEBUG:     return ANDROID_LOG_VERBOSE;
 204         }
 205         return ANDROID_LOG_UNKNOWN;
 206 }
 207
 208 #define LOG_MESSAGE_MAX_LEN 4096
 209
 210 static void
 211 android_log_line (gint log_priority, const gchar *log_domain, const gchar *log_message, gint log_len)
 212 {
 213         gchar log_buf [LOG_MESSAGE_MAX_LEN];
 214
 215         g_assert (log_len <= LOG_MESSAGE_MAX_LEN - 1);
 216
 217         /* If line is longer than LOG_MESSAGE_MAX_LEN - 1, then we simply cut it out. This is consistent with the previous behavior. */
 218         strncpy (log_buf, log_message, log_len);
 219         log_buf [log_len] = '\0';
 220
 221         __android_log_write (log_priority, log_domain, log_buf);
 222 }
 223
 224 static void
 225 android_log (gint log_priority, const gchar *log_domain, const gchar *log_message)
 226 {
 227         gint log_message_len, log_message_p_len;
 228         const gchar *log_message_p;
 229
 230         log_message_len = strlen (log_message);
 231         if (log_message_len <= LOG_MESSAGE_MAX_LEN) {
 232                 __android_log_write (log_priority, log_domain, log_message);
 233                 return;
 234         }
 235
 236         for (log_message_p = log_message; log_message_p < log_message + log_message_len;) {
 237                 const gchar *p = strstr (log_message_p, "\n");
 238                 if (p == NULL) {
 239                         /* There is no more "\n". */
 240                         android_log_line (log_priority, log_domain, log_message_p, LOG_MESSAGE_MAX_LEN - 1);
 241                         break;
 242                 }
 243
 244                 log_message_p_len = p - log_message_p;
 245                 if (log_message_p_len > LOG_MESSAGE_MAX_LEN - 1)
 246                         log_message_p_len = LOG_MESSAGE_MAX_LEN - 1;
 247
 248                 android_log_line (log_priority, log_domain, log_message_p, log_message_p_len);
 249
 250                 /* Set `log_message_p` to the character right after "\n" */
 251                 log_message_p = p + 1;
 252         }
 253 }
 254
 255 void
 256 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 257 {
 258         android_log (to_android_priority (log_level), log_domain, message);
 259         if (log_level & fatal)
 260                 g_assert_abort ();
 261 }
 262
 263 static void
 264 default_stdout_handler (const gchar *message)
 265 {
 266         /* TODO: provide a proper app name */
 267         android_log (ANDROID_LOG_ERROR, "mono", message);
 268 }
 269
 270 static void
 271 default_stderr_handler (const gchar *message)
 272 {
 273         /* TODO: provide a proper app name */
 274         android_log (ANDROID_LOG_ERROR, "mono", message);
 275 }
 276
 277
 278 #elif defined(HOST_IOS)
 279 #include <asl.h>
 280
 281 static int
 282 to_asl_priority (GLogLevelFlags log_level)
 283 {
 284         switch (log_level & G_LOG_LEVEL_MASK)
 285         {
 286                 case G_LOG_LEVEL_ERROR:     return ASL_LEVEL_CRIT;
 287                 case G_LOG_LEVEL_CRITICAL:  return ASL_LEVEL_ERR;
 288                 case G_LOG_LEVEL_WARNING:   return ASL_LEVEL_WARNING;
 289                 case G_LOG_LEVEL_MESSAGE:   return ASL_LEVEL_NOTICE;
 290                 case G_LOG_LEVEL_INFO:      return ASL_LEVEL_INFO;
 291                 case G_LOG_LEVEL_DEBUG:     return ASL_LEVEL_DEBUG;
 292         }
 293         return ASL_LEVEL_ERR;
 294 }
 295
 296 void
 297 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 298 {
 299         asl_log (NULL, NULL, to_asl_priority (log_level), "%s", message);
 300         if (log_level & fatal)
 301                 g_assert_abort ();
 302 }
 303
 304 static void
 305 default_stdout_handler (const gchar *message)
 306 {
 307         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 308 }
 309
 310 static void
 311 default_stderr_handler (const gchar *message)
 312 {
 313         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 314 }
 315
 316 #else
 317
 318 void
 319 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 320 {
 321         FILE *target = stdout;
 322
 323         fprintf (target, "%s%s%s\n",
 324                 log_domain != NULL ? log_domain : "",
 325                 log_domain != NULL ? ": " : "",
 326                 message);
 327
 328         if (log_level & fatal) {
 329                 fflush (stdout);
 330                 fflush (stderr);
 331                 g_assert_abort ();
 332         }
 333 }
 334
 335 static void
 336 default_stdout_handler (const gchar *string)
 337 {
 338         fprintf (stdout, "%s", string);
 339 }
 340
 341 static void
 342 default_stderr_handler (const gchar *string)
 343 {
 344         fprintf (stderr, "%s", string);
 345 }
 346
 347 #endif
 348
 349 GLogFunc
 350 g_log_set_default_handler (GLogFunc log_func, gpointer user_data)
 351 {
 352         GLogFunc old = default_log_func;
 353         default_log_func = log_func;
 354         default_log_func_user_data = user_data;
 355         return old;
 356 }
 357
 358 GPrintFunc
 359 g_set_print_handler (GPrintFunc func)
 360 {
 361         GPrintFunc old = stdout_handler;
 362         stdout_handler = func;
 363         return old;
 364 }
 365
 366 GPrintFunc
 367 g_set_printerr_handler (GPrintFunc func)
 368 {
 369         GPrintFunc old = stderr_handler;
 370         stderr_handler = func;
 371         return old;
 372 }
 373