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 // Emscriptem emulates varargs, and fails to stack pack multiple outgoing varargs areas,
 191 // so this function serves to remove varargs in its caller and conserve stack.
 192 void
 193 mono_assertion_message_disabled (const char *file, int line)
 194 {
 195         mono_assertion_message (file, line, "<disabled>");
 196 }
 197
 198 // Emscriptem emulates varargs, and fails to stack pack multiple outgoing varargs areas,
 199 // so this function serves to remove varargs in its caller and conserve stack.
 200 void
 201 mono_assertion_message (const char *file, int line, const char *condition)
 202 {
 203         g_assertion_message ("* Assertion at %s:%d, condition `%s' not met\n", file, line, condition);
 204 }
 205
 206 // Emscriptem emulates varargs, and fails to stack pack multiple outgoing varargs areas,
 207 // so this function serves to remove varargs in its caller and conserve stack.
 208 void
 209 mono_assertion_message_unreachable (const char *file, int line)
 210 {
 211         g_assertion_message ("* Assertion: should not be reached at %s:%d\n", file, line);
 212 }
 213
 214 #if HOST_ANDROID
 215 #include <android/log.h>
 216
 217 static android_LogPriority
 218 to_android_priority (GLogLevelFlags log_level)
 219 {
 220         switch (log_level & G_LOG_LEVEL_MASK)
 221         {
 222                 case G_LOG_LEVEL_ERROR:     return ANDROID_LOG_FATAL;
 223                 case G_LOG_LEVEL_CRITICAL:  return ANDROID_LOG_ERROR;
 224                 case G_LOG_LEVEL_WARNING:   return ANDROID_LOG_WARN;
 225                 case G_LOG_LEVEL_MESSAGE:   return ANDROID_LOG_INFO;
 226                 case G_LOG_LEVEL_INFO:      return ANDROID_LOG_DEBUG;
 227                 case G_LOG_LEVEL_DEBUG:     return ANDROID_LOG_VERBOSE;
 228         }
 229         return ANDROID_LOG_UNKNOWN;
 230 }
 231
 232 #define LOG_MESSAGE_MAX_LEN 4096
 233
 234 static void
 235 android_log_line (gint log_priority, const gchar *log_domain, const gchar *log_message, gint log_len)
 236 {
 237         gchar log_buf [LOG_MESSAGE_MAX_LEN];
 238
 239         g_assert (log_len <= LOG_MESSAGE_MAX_LEN - 1);
 240
 241         /* If line is longer than LOG_MESSAGE_MAX_LEN - 1, then we simply cut it out. This is consistent with the previous behavior. */
 242         strncpy (log_buf, log_message, log_len);
 243         log_buf [log_len] = '\0';
 244
 245         __android_log_write (log_priority, log_domain, log_buf);
 246 }
 247
 248 static void
 249 android_log (gint log_priority, const gchar *log_domain, const gchar *log_message)
 250 {
 251         gint log_message_len, log_message_p_len;
 252         const gchar *log_message_p;
 253
 254         log_message_len = strlen (log_message);
 255         if (log_message_len <= LOG_MESSAGE_MAX_LEN) {
 256                 __android_log_write (log_priority, log_domain, log_message);
 257                 return;
 258         }
 259
 260         for (log_message_p = log_message; log_message_p < log_message + log_message_len;) {
 261                 const gchar *p = strstr (log_message_p, "\n");
 262                 if (p == NULL) {
 263                         /* There is no more "\n". */
 264                         android_log_line (log_priority, log_domain, log_message_p, LOG_MESSAGE_MAX_LEN - 1);
 265                         break;
 266                 }
 267
 268                 log_message_p_len = p - log_message_p;
 269                 if (log_message_p_len > LOG_MESSAGE_MAX_LEN - 1)
 270                         log_message_p_len = LOG_MESSAGE_MAX_LEN - 1;
 271
 272                 android_log_line (log_priority, log_domain, log_message_p, log_message_p_len);
 273
 274                 /* Set `log_message_p` to the character right after "\n" */
 275                 log_message_p = p + 1;
 276         }
 277 }
 278
 279 void
 280 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 281 {
 282         android_log (to_android_priority (log_level), log_domain, message);
 283         if (log_level & fatal)
 284                 g_assert_abort ();
 285 }
 286
 287 static void
 288 default_stdout_handler (const gchar *message)
 289 {
 290         /* TODO: provide a proper app name */
 291         android_log (ANDROID_LOG_ERROR, "mono", message);
 292 }
 293
 294 static void
 295 default_stderr_handler (const gchar *message)
 296 {
 297         /* TODO: provide a proper app name */
 298         android_log (ANDROID_LOG_ERROR, "mono", message);
 299 }
 300
 301
 302 #elif defined(HOST_IOS)
 303 #include <asl.h>
 304
 305 static int
 306 to_asl_priority (GLogLevelFlags log_level)
 307 {
 308         switch (log_level & G_LOG_LEVEL_MASK)
 309         {
 310                 case G_LOG_LEVEL_ERROR:     return ASL_LEVEL_CRIT;
 311                 case G_LOG_LEVEL_CRITICAL:  return ASL_LEVEL_ERR;
 312                 case G_LOG_LEVEL_WARNING:   return ASL_LEVEL_WARNING;
 313                 case G_LOG_LEVEL_MESSAGE:   return ASL_LEVEL_NOTICE;
 314                 case G_LOG_LEVEL_INFO:      return ASL_LEVEL_INFO;
 315                 case G_LOG_LEVEL_DEBUG:     return ASL_LEVEL_DEBUG;
 316         }
 317         return ASL_LEVEL_ERR;
 318 }
 319
 320 void
 321 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 322 {
 323         asl_log (NULL, NULL, to_asl_priority (log_level), "%s", message);
 324         if (log_level & fatal)
 325                 g_assert_abort ();
 326 }
 327
 328 static void
 329 default_stdout_handler (const gchar *message)
 330 {
 331         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 332 }
 333
 334 static void
 335 default_stderr_handler (const gchar *message)
 336 {
 337         asl_log (NULL, NULL, ASL_LEVEL_WARNING, "%s", message);
 338 }
 339
 340 #else
 341
 342 void
 343 g_log_default_handler (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer unused_data)
 344 {
 345         FILE *target = stdout;
 346
 347         fprintf (target, "%s%s%s\n",
 348                 log_domain != NULL ? log_domain : "",
 349                 log_domain != NULL ? ": " : "",
 350                 message);
 351
 352         if (log_level & fatal) {
 353                 fflush (stdout);
 354                 fflush (stderr);
 355                 g_assert_abort ();
 356         }
 357 }
 358
 359 static void
 360 default_stdout_handler (const gchar *string)
 361 {
 362         fprintf (stdout, "%s", string);
 363 }
 364
 365 static void
 366 default_stderr_handler (const gchar *string)
 367 {
 368         fprintf (stderr, "%s", string);
 369 }
 370
 371 #endif
 372
 373 GLogFunc
 374 g_log_set_default_handler (GLogFunc log_func, gpointer user_data)
 375 {
 376         GLogFunc old = default_log_func;
 377         default_log_func = log_func;
 378         default_log_func_user_data = user_data;
 379         return old;
 380 }
 381
 382 GPrintFunc
 383 g_set_print_handler (GPrintFunc func)
 384 {
 385         GPrintFunc old = stdout_handler;
 386         stdout_handler = func;
 387         return old;
 388 }
 389
 390 GPrintFunc
 391 g_set_printerr_handler (GPrintFunc func)
 392 {
 393         GPrintFunc old = stderr_handler;
 394         stderr_handler = func;
 395         return old;
 396 }
 397