glib/gmessages.c

   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 /*
  28  * MT safe
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <stdarg.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include "glib.h"
  40 #ifdef HAVE_UNISTD_H
  41 #include <unistd.h>
  42 #endif
  43 #include <signal.h>
  44 #include <locale.h>
  45 #include <errno.h>
  46 #include "gdebug.h"
  47
  48 #ifdef G_OS_WIN32
  49 typedef FILE* GFileDescriptor;
  50 #else
  51 typedef gint GFileDescriptor;
  52 #endif
  53
  54 /* --- structures --- */
  55 typedef struct _GLogDomain      GLogDomain;
  56 typedef struct _GLogHandler     GLogHandler;
  57 struct _GLogDomain
  58 {
  59   gchar         *log_domain;
  60   GLogLevelFlags fatal_mask;
  61   GLogHandler   *handlers;
  62   GLogDomain    *next;
  63 };
  64 struct _GLogHandler
  65 {
  66   guint          id;
  67   GLogLevelFlags log_level;
  68   GLogFunc       log_func;
  69   gpointer       data;
  70   GLogHandler   *next;
  71 };
  72
  73
  74 /* --- prototypes --- */
  75 #ifndef HAVE_C99_VSNPRINTF
  76 static gsize printf_string_upper_bound (const gchar *format,
  77                                         gboolean     may_warn,
  78                                         va_list      args);
  79 #endif /* !HAVE_C99_VSNPRINTF */
  80
  81
  82 /* --- variables --- */
  83 static GMutex        *g_messages_lock = NULL;
  84 static GLogDomain    *g_log_domains = NULL;
  85 static GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;
  86 static GPrintFunc     glib_print_func = NULL;
  87 static GPrintFunc     glib_printerr_func = NULL;
  88 static GPrivate      *g_log_depth = NULL;
  89 static GLogLevelFlags g_log_msg_prefix = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_DEBUG;
  90
  91
  92 /* --- functions --- */
  93 #ifdef G_OS_WIN32
  94 #  define STRICT
  95 #  include <windows.h>
  96 #  undef STRICT
  97 #  include <process.h>          /* For _getpid() */
  98 static gboolean alloc_console_called = FALSE;
  99 static gboolean win32_keep_fatal_message = FALSE;
 100
 101 /* This default message will usually be overwritten. */
 102 /* Yes, a fixed size buffer is bad. So sue me. But g_error is never
 103  * with huge strings, is it?
 104  */
 105 static gchar  fatal_msg_buf[1000] = "Unspecified fatal error encountered, aborting.";
 106 static gchar *fatal_msg_ptr = fatal_msg_buf;
 107
 108 /* Just use stdio. If we're out of memory, we're hosed anyway. */
 109 #undef write
 110 static inline int
 111 dowrite (GFileDescriptor fd,
 112          const void  *buf,
 113          unsigned int len)
 114 {
 115   if (win32_keep_fatal_message)
 116     {
 117       memcpy (fatal_msg_ptr, buf, len);
 118       fatal_msg_ptr += len;
 119       *fatal_msg_ptr = 0;
 120       return len;
 121     }
 122
 123   fwrite (buf, len, 1, fd);
 124   fflush (fd);
 125
 126   return len;
 127 }
 128 #define write(fd, buf, len) dowrite(fd, buf, len)
 129
 130 static void
 131 ensure_stdout_valid (void)
 132 {
 133   HANDLE handle;
 134
 135   if (win32_keep_fatal_message)
 136     return;
 137
 138   if (!alloc_console_called)
 139     {
 140       handle = GetStdHandle (STD_OUTPUT_HANDLE);
 141
 142       if (handle == INVALID_HANDLE_VALUE)
 143         {
 144           AllocConsole ();
 145           alloc_console_called = TRUE;
 146           freopen ("CONOUT$", "w", stdout);
 147         }
 148     }
 149 }
 150 #else
 151 #define ensure_stdout_valid()   /* Define as empty */
 152 #endif
 153
 154 static void
 155 write_string (GFileDescriptor fd,
 156               const gchar    *string)
 157 {
 158   write (fd, string, strlen (string));
 159 }
 160
 161 static void
 162 g_messages_prefixed_init (void)
 163 {
 164   static gboolean initialized = FALSE;
 165
 166   if (!initialized)
 167     {
 168       const gchar *val;
 169
 170       initialized = TRUE;
 171       val = g_getenv ("G_MESSAGES_PREFIXED");
 172
 173       if (val)
 174         {
 175           static const GDebugKey keys[] = {
 176             { "error", G_LOG_LEVEL_ERROR },
 177             { "critical", G_LOG_LEVEL_CRITICAL },
 178             { "warning", G_LOG_LEVEL_WARNING },
 179             { "message", G_LOG_LEVEL_MESSAGE },
 180             { "info", G_LOG_LEVEL_INFO },
 181             { "debug", G_LOG_LEVEL_DEBUG }
 182           };
 183
 184           g_log_msg_prefix = g_parse_debug_string (val, keys, G_N_ELEMENTS (keys));
 185         }
 186     }
 187 }
 188
 189 static GLogDomain*
 190 g_log_find_domain_L (const gchar *log_domain)
 191 {
 192   register GLogDomain *domain;
 193
 194   domain = g_log_domains;
 195   while (domain)
 196     {
 197       if (strcmp (domain->log_domain, log_domain) == 0)
 198         return domain;
 199       domain = domain->next;
 200     }
 201   return NULL;
 202 }
 203
 204 static GLogDomain*
 205 g_log_domain_new_L (const gchar *log_domain)
 206 {
 207   register GLogDomain *domain;
 208
 209   domain = g_new (GLogDomain, 1);
 210   domain->log_domain = g_strdup (log_domain);
 211   domain->fatal_mask = G_LOG_FATAL_MASK;
 212   domain->handlers = NULL;
 213
 214   domain->next = g_log_domains;
 215   g_log_domains = domain;
 216
 217   return domain;
 218 }
 219
 220 static void
 221 g_log_domain_check_free_L (GLogDomain *domain)
 222 {
 223   if (domain->fatal_mask == G_LOG_FATAL_MASK &&
 224       domain->handlers == NULL)
 225     {
 226       register GLogDomain *last, *work;
 227
 228       last = NULL;
 229
 230       work = g_log_domains;
 231       while (work)
 232         {
 233           if (work == domain)
 234             {
 235               if (last)
 236                 last->next = domain->next;
 237               else
 238                 g_log_domains = domain->next;
 239               g_free (domain->log_domain);
 240               g_free (domain);
 241               break;
 242             }
 243           last = work;
 244           work = last->next;
 245         }
 246     }
 247 }
 248
 249 static GLogFunc
 250 g_log_domain_get_handler_L (GLogDomain  *domain,
 251                             GLogLevelFlags log_level,
 252                             gpointer    *data)
 253 {
 254   if (domain && log_level)
 255     {
 256       register GLogHandler *handler;
 257
 258       handler = domain->handlers;
 259       while (handler)
 260         {
 261           if ((handler->log_level & log_level) == log_level)
 262             {
 263               *data = handler->data;
 264               return handler->log_func;
 265             }
 266           handler = handler->next;
 267         }
 268     }
 269   return g_log_default_handler;
 270 }
 271
 272 GLogLevelFlags
 273 g_log_set_always_fatal (GLogLevelFlags fatal_mask)
 274 {
 275   GLogLevelFlags old_mask;
 276
 277   /* restrict the global mask to levels that are known to glib
 278    * since this setting applies to all domains
 279    */
 280   fatal_mask &= (1 << G_LOG_LEVEL_USER_SHIFT) - 1;
 281   /* force errors to be fatal */
 282   fatal_mask |= G_LOG_LEVEL_ERROR;
 283   /* remove bogus flag */
 284   fatal_mask &= ~G_LOG_FLAG_FATAL;
 285
 286   g_mutex_lock (g_messages_lock);
 287   old_mask = g_log_always_fatal;
 288   g_log_always_fatal = fatal_mask;
 289   g_mutex_unlock (g_messages_lock);
 290
 291   return old_mask;
 292 }
 293
 294 GLogLevelFlags
 295 g_log_set_fatal_mask (const gchar   *log_domain,
 296                       GLogLevelFlags fatal_mask)
 297 {
 298   GLogLevelFlags old_flags;
 299   register GLogDomain *domain;
 300
 301   if (!log_domain)
 302     log_domain = "";
 303
 304   /* force errors to be fatal */
 305   fatal_mask |= G_LOG_LEVEL_ERROR;
 306   /* remove bogus flag */
 307   fatal_mask &= ~G_LOG_FLAG_FATAL;
 308
 309   g_mutex_lock (g_messages_lock);
 310
 311   domain = g_log_find_domain_L (log_domain);
 312   if (!domain)
 313     domain = g_log_domain_new_L (log_domain);
 314   old_flags = domain->fatal_mask;
 315
 316   domain->fatal_mask = fatal_mask;
 317   g_log_domain_check_free_L (domain);
 318
 319   g_mutex_unlock (g_messages_lock);
 320
 321   return old_flags;
 322 }
 323
 324 guint
 325 g_log_set_handler (const gchar   *log_domain,
 326                    GLogLevelFlags log_levels,
 327                    GLogFunc       log_func,
 328                    gpointer       user_data)
 329 {
 330   static guint handler_id = 0;
 331   GLogDomain *domain;
 332   GLogHandler *handler;
 333
 334   g_return_val_if_fail ((log_levels & G_LOG_LEVEL_MASK) != 0, 0);
 335   g_return_val_if_fail (log_func != NULL, 0);
 336
 337   if (!log_domain)
 338     log_domain = "";
 339
 340   handler = g_new (GLogHandler, 1);
 341
 342   g_mutex_lock (g_messages_lock);
 343
 344   domain = g_log_find_domain_L (log_domain);
 345   if (!domain)
 346     domain = g_log_domain_new_L (log_domain);
 347
 348   handler->id = ++handler_id;
 349   handler->log_level = log_levels;
 350   handler->log_func = log_func;
 351   handler->data = user_data;
 352   handler->next = domain->handlers;
 353   domain->handlers = handler;
 354
 355   g_mutex_unlock (g_messages_lock);
 356
 357   return handler_id;
 358 }
 359
 360 void
 361 g_log_remove_handler (const gchar *log_domain,
 362                       guint        handler_id)
 363 {
 364   register GLogDomain *domain;
 365
 366   g_return_if_fail (handler_id > 0);
 367
 368   if (!log_domain)
 369     log_domain = "";
 370
 371   g_mutex_lock (g_messages_lock);
 372   domain = g_log_find_domain_L (log_domain);
 373   if (domain)
 374     {
 375       GLogHandler *work, *last;
 376
 377       last = NULL;
 378       work = domain->handlers;
 379       while (work)
 380         {
 381           if (work->id == handler_id)
 382             {
 383               if (last)
 384                 last->next = work->next;
 385               else
 386                 domain->handlers = work->next;
 387               g_log_domain_check_free_L (domain);
 388               g_mutex_unlock (g_messages_lock);
 389               g_free (work);
 390               return;
 391             }
 392           last = work;
 393           work = last->next;
 394         }
 395     }
 396   g_mutex_unlock (g_messages_lock);
 397   g_warning ("%s: could not find handler with id `%d' for domain \"%s\"",
 398              G_STRLOC, handler_id, log_domain);
 399 }
 400
 401 void
 402 g_logv (const gchar   *log_domain,
 403         GLogLevelFlags log_level,
 404         const gchar   *format,
 405         va_list        args1)
 406 {
 407   gchar buffer[1025];
 408   gboolean was_fatal = (log_level & G_LOG_FLAG_FATAL) != 0;
 409   gboolean was_recursion = (log_level & G_LOG_FLAG_RECURSION) != 0;
 410   gint i;
 411
 412 #ifndef  HAVE_VSNPRINTF
 413   va_list args2;
 414 #endif  /* HAVE_VSNPRINTF */
 415
 416   log_level &= G_LOG_LEVEL_MASK;
 417   if (!log_level)
 418     return;
 419
 420   /* we use a stack buffer of fixed size, because we might get called
 421    * recursively.
 422    */
 423 #ifdef  HAVE_VSNPRINTF
 424   vsnprintf (buffer, 1024, format, args1);
 425 #else   /* !HAVE_VSNPRINTF */
 426   G_VA_COPY (args2, args1);
 427   if (printf_string_upper_bound (format, FALSE, args1) < 1024)
 428     vsprintf (buffer, format, args2);
 429   else
 430     {
 431       /* since we might be out of memory, we can't use g_vsnprintf(). */
 432       /* we are out of luck here */
 433       strncpy (buffer, format, 1024);
 434       buffer[1024] = 0;
 435     }
 436   va_end (args2);
 437 #endif  /* !HAVE_VSNPRINTF */
 438
 439   for (i = g_bit_nth_msf (log_level, -1); i >= 0; i = g_bit_nth_msf (log_level, i))
 440     {
 441       register GLogLevelFlags test_level;
 442
 443       test_level = 1 << i;
 444       if (log_level & test_level)
 445         {
 446           guint depth = GPOINTER_TO_UINT (g_private_get (g_log_depth));
 447           GLogDomain *domain;
 448           GLogFunc log_func;
 449           guint domain_fatal_mask;
 450           gpointer data = NULL;
 451
 452           if (was_fatal)
 453             test_level |= G_LOG_FLAG_FATAL;
 454           if (was_recursion)
 455             test_level |= G_LOG_FLAG_RECURSION;
 456
 457           /* check recursion and lookup handler */
 458           g_mutex_lock (g_messages_lock);
 459           domain = g_log_find_domain_L (log_domain ? log_domain : "");
 460           if (depth)
 461             test_level |= G_LOG_FLAG_RECURSION;
 462           depth++;
 463           domain_fatal_mask = domain ? domain->fatal_mask : G_LOG_FATAL_MASK;
 464           if ((domain_fatal_mask | g_log_always_fatal) & test_level)
 465             test_level |= G_LOG_FLAG_FATAL;
 466           if (test_level & G_LOG_FLAG_RECURSION)
 467             log_func = _g_log_fallback_handler;
 468           else
 469             log_func = g_log_domain_get_handler_L (domain, test_level, &data);
 470           domain = NULL;
 471           g_mutex_unlock (g_messages_lock);
 472
 473           g_private_set (g_log_depth, GUINT_TO_POINTER (depth));
 474
 475           /* had to defer debug initialization until we can keep track of recursion */
 476           if (!(test_level & G_LOG_FLAG_RECURSION) && !_g_debug_initialized)
 477             {
 478               guint orig_test_level = test_level;
 479
 480               _g_debug_init ();
 481               if ((domain_fatal_mask | g_log_always_fatal) & test_level)
 482                 test_level |= G_LOG_FLAG_FATAL;
 483               if (test_level != orig_test_level)
 484                 {
 485                   /* need a relookup, not nice, but not too bad either */
 486                   g_mutex_lock (g_messages_lock);
 487                   domain = g_log_find_domain_L (log_domain ? log_domain : "");
 488                   log_func = g_log_domain_get_handler_L (domain, test_level, &data);
 489                   domain = NULL;
 490                   g_mutex_unlock (g_messages_lock);
 491                 }
 492             }
 493
 494           log_func (log_domain, test_level, buffer, data);
 495
 496           if (test_level & G_LOG_FLAG_FATAL)
 497             {
 498 #ifdef G_OS_WIN32
 499               MessageBox (NULL, fatal_msg_buf, NULL, MB_OK);
 500 #endif
 501 #if defined (G_ENABLE_DEBUG) && (defined (SIGTRAP) || defined (G_OS_WIN32))
 502               if (!(test_level & G_LOG_FLAG_RECURSION))
 503                 G_BREAKPOINT ();
 504               else
 505                 abort ();
 506 #else /* !G_ENABLE_DEBUG || !(SIGTRAP || G_OS_WIN32) */
 507               abort ();
 508 #endif /* !G_ENABLE_DEBUG || !(SIGTRAP || G_OS_WIN32) */
 509             }
 510
 511           depth--;
 512           g_private_set (g_log_depth, GUINT_TO_POINTER (depth));
 513         }
 514     }
 515 }
 516
 517 void
 518 g_log (const gchar   *log_domain,
 519        GLogLevelFlags log_level,
 520        const gchar   *format,
 521        ...)
 522 {
 523   va_list args;
 524
 525   va_start (args, format);
 526   g_logv (log_domain, log_level, format, args);
 527   va_end (args);
 528 }
 529
 530 /* For a radix of 8 we need at most 3 output bytes for 1 input
 531  * byte. Additionally we might need up to 2 output bytes for the
 532  * readix prefix and 1 byte for the trailing NULL.
 533  */
 534 #define FORMAT_UNSIGNED_BUFSIZE ((GLIB_SIZEOF_LONG * 3) + 3)
 535
 536 static void
 537 format_unsigned (gchar  *buf,
 538                  gulong  num,
 539                  guint   radix)
 540 {
 541   gulong tmp;
 542   gchar c;
 543   gint i, n;
 544
 545   /* we may not call _any_ GLib functions here (or macros like g_return_if_fail()) */
 546
 547   if (radix != 8 && radix != 10 && radix != 16)
 548     {
 549       *buf = '\000';
 550       return;
 551     }
 552
 553   if (!num)
 554     {
 555       *buf++ = '0';
 556       *buf = '\000';
 557       return;
 558     }
 559
 560   if (radix == 16)
 561     {
 562       *buf++ = '0';
 563       *buf++ = 'x';
 564     }
 565   else if (radix == 8)
 566     {
 567       *buf++ = '0';
 568     }
 569
 570   n = 0;
 571   tmp = num;
 572   while (tmp)
 573     {
 574       tmp /= radix;
 575       n++;
 576     }
 577
 578   i = n;
 579
 580   /* Again we can't use g_assert; actually this check should _never_ fail. */
 581   if (n > FORMAT_UNSIGNED_BUFSIZE - 3)
 582     {
 583       *buf = '\000';
 584       return;
 585     }
 586
 587   while (num)
 588     {
 589       i--;
 590       c = (num % radix);
 591       if (c < 10)
 592         buf[i] = c + '0';
 593       else
 594         buf[i] = c + 'a' - 10;
 595       num /= radix;
 596     }
 597
 598   buf[n] = '\000';
 599 }
 600
 601 /* string size big enough to hold level prefix */
 602 #define STRING_BUFFER_SIZE      (FORMAT_UNSIGNED_BUFSIZE + 32)
 603
 604 #define ALERT_LEVELS            (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING)
 605
 606 static GFileDescriptor
 607 mklevel_prefix (gchar level_prefix[STRING_BUFFER_SIZE],
 608                 guint log_level)
 609 {
 610   gboolean to_stdout = TRUE;
 611
 612   /* we may not call _any_ GLib functions here */
 613
 614   switch (log_level & G_LOG_LEVEL_MASK)
 615     {
 616     case G_LOG_LEVEL_ERROR:
 617       strcpy (level_prefix, "ERROR");
 618       to_stdout = FALSE;
 619       break;
 620     case G_LOG_LEVEL_CRITICAL:
 621       strcpy (level_prefix, "CRITICAL");
 622       to_stdout = FALSE;
 623       break;
 624     case G_LOG_LEVEL_WARNING:
 625       strcpy (level_prefix, "WARNING");
 626       to_stdout = FALSE;
 627       break;
 628     case G_LOG_LEVEL_MESSAGE:
 629       strcpy (level_prefix, "Message");
 630       to_stdout = FALSE;
 631       break;
 632     case G_LOG_LEVEL_INFO:
 633       strcpy (level_prefix, "INFO");
 634       break;
 635     case G_LOG_LEVEL_DEBUG:
 636       strcpy (level_prefix, "DEBUG");
 637       break;
 638     default:
 639       if (log_level)
 640         {
 641           strcpy (level_prefix, "LOG-");
 642           format_unsigned (level_prefix + 4, log_level & G_LOG_LEVEL_MASK, 16);
 643         }
 644       else
 645         strcpy (level_prefix, "LOG");
 646       break;
 647     }
 648   if (log_level & G_LOG_FLAG_RECURSION)
 649     strcat (level_prefix, " (recursed)");
 650   if (log_level & ALERT_LEVELS)
 651     strcat (level_prefix, " **");
 652
 653   ensure_stdout_valid ();
 654 #ifdef G_OS_WIN32
 655   win32_keep_fatal_message = (log_level & G_LOG_FLAG_FATAL) != 0;
 656   /* Use just stdout as stderr is hard to get redirected from the DOS prompt. */
 657   return stdout;
 658 #else
 659   return to_stdout ? 1 : 2;
 660 #endif
 661 }
 662
 663 void
 664 _g_log_fallback_handler (const gchar   *log_domain,
 665                          GLogLevelFlags log_level,
 666                          const gchar   *message,
 667                          gpointer       unused_data)
 668 {
 669   gchar level_prefix[STRING_BUFFER_SIZE], pid_string[FORMAT_UNSIGNED_BUFSIZE];
 670   gboolean is_fatal = (log_level & G_LOG_FLAG_FATAL) != 0;
 671   GFileDescriptor fd;
 672
 673   /* we can not call _any_ GLib functions in this fallback handler,
 674    * which is why we skip UTF-8 conversion, etc.
 675    * since we either recursed or ran out of memory, we're in a pretty
 676    * pathologic situation anyways, what we can do is giving the
 677    * the process ID unconditionally however.
 678    */
 679
 680   fd = mklevel_prefix (level_prefix, log_level);
 681   if (!message)
 682     message = "(NULL) message";
 683
 684   format_unsigned (pid_string, getpid (), 10);
 685
 686   if (log_domain)
 687     write_string (fd, "\n");
 688   else
 689     write_string (fd, "\n** ");
 690   write_string (fd, "(process:");
 691   write_string (fd, pid_string);
 692   write_string (fd, "): ");
 693   if (log_domain)
 694     {
 695       write_string (fd, log_domain);
 696       write_string (fd, "-");
 697     }
 698   write_string (fd, level_prefix);
 699   write_string (fd, ": ");
 700   write_string (fd, message);
 701   if (is_fatal)
 702     write_string (fd, "\naborting...\n");
 703   else
 704     write_string (fd, "\n");
 705 }
 706
 707 void
 708 g_log_default_handler (const gchar   *log_domain,
 709                        GLogLevelFlags log_level,
 710                        const gchar   *message,
 711                        gpointer       unused_data)
 712 {
 713   gboolean is_fatal = (log_level & G_LOG_FLAG_FATAL) != 0;
 714   gchar level_prefix[STRING_BUFFER_SIZE], *string;
 715   GString *gstring;
 716   GFileDescriptor fd;
 717
 718   /* we can be called externally with recursion for whatever reason */
 719   if (log_level & G_LOG_FLAG_RECURSION)
 720     {
 721       _g_log_fallback_handler (log_domain, log_level, message, unused_data);
 722       return;
 723     }
 724
 725   g_messages_prefixed_init ();
 726
 727   fd = mklevel_prefix (level_prefix, log_level);
 728
 729   gstring = g_string_new ("");
 730   if (log_level & ALERT_LEVELS)
 731     g_string_append (gstring, "\n");
 732   if (!log_domain)
 733     g_string_append (gstring, "** ");
 734
 735   if ((g_log_msg_prefix & log_level) == log_level)
 736     {
 737       const gchar *prg_name = g_get_prgname ();
 738
 739       if (!prg_name)
 740         g_string_append_printf (gstring, "(process:%u): ", getpid ());
 741       else
 742         g_string_append_printf (gstring, "(%s:%u): ", prg_name, getpid ());
 743     }
 744
 745   if (log_domain)
 746     {
 747       g_string_append (gstring, log_domain);
 748       g_string_append_c (gstring, '-');
 749     }
 750   g_string_append (gstring, level_prefix);
 751
 752   g_string_append (gstring, ": ");
 753   if (!message)
 754     g_string_append (gstring, "(NULL) message");
 755   else
 756     {
 757       const gchar *charset;
 758
 759       if (g_get_charset (&charset))
 760         g_string_append (gstring, message);     /* charset is UTF-8 already */
 761       else
 762         {
 763           if (!g_utf8_validate (message, -1, NULL))
 764             {
 765               g_string_append (gstring, "[Invalid UTF-8] ");
 766               g_string_append (gstring, message);
 767             }
 768           else
 769             {
 770               string = g_convert_with_fallback (message, -1, charset, "UTF-8",
 771                                                 ".", NULL, NULL, NULL);
 772               g_string_append (gstring, string);
 773               g_free (string);
 774             }
 775         }
 776     }
 777   if (is_fatal)
 778     g_string_append (gstring, "\naborting...\n");
 779   else
 780     g_string_append (gstring, "\n");
 781
 782   string = g_string_free (gstring, FALSE);
 783
 784   write_string (fd, string);
 785   g_free (string);
 786 }
 787
 788 GPrintFunc
 789 g_set_print_handler (GPrintFunc func)
 790 {
 791   GPrintFunc old_print_func;
 792
 793   g_mutex_lock (g_messages_lock);
 794   old_print_func = glib_print_func;
 795   glib_print_func = func;
 796   g_mutex_unlock (g_messages_lock);
 797
 798   return old_print_func;
 799 }
 800
 801 void
 802 g_print (const gchar *format,
 803          ...)
 804 {
 805   va_list args;
 806   gchar *string;
 807   GPrintFunc local_glib_print_func;
 808
 809   g_return_if_fail (format != NULL);
 810
 811   va_start (args, format);
 812   string = g_strdup_vprintf (format, args);
 813   va_end (args);
 814
 815   g_mutex_lock (g_messages_lock);
 816   local_glib_print_func = glib_print_func;
 817   g_mutex_unlock (g_messages_lock);
 818
 819   if (local_glib_print_func)
 820     local_glib_print_func (string);
 821   else
 822     {
 823       ensure_stdout_valid ();
 824       fputs (string, stdout);
 825       fflush (stdout);
 826     }
 827   g_free (string);
 828 }
 829
 830 GPrintFunc
 831 g_set_printerr_handler (GPrintFunc func)
 832 {
 833   GPrintFunc old_printerr_func;
 834
 835   g_mutex_lock (g_messages_lock);
 836   old_printerr_func = glib_printerr_func;
 837   glib_printerr_func = func;
 838   g_mutex_unlock (g_messages_lock);
 839
 840   return old_printerr_func;
 841 }
 842
 843 void
 844 g_printerr (const gchar *format,
 845             ...)
 846 {
 847   va_list args;
 848   gchar *string;
 849   GPrintFunc local_glib_printerr_func;
 850
 851   g_return_if_fail (format != NULL);
 852
 853   va_start (args, format);
 854   string = g_strdup_vprintf (format, args);
 855   va_end (args);
 856
 857   g_mutex_lock (g_messages_lock);
 858   local_glib_printerr_func = glib_printerr_func;
 859   g_mutex_unlock (g_messages_lock);
 860
 861   if (local_glib_printerr_func)
 862     local_glib_printerr_func (string);
 863   else
 864     {
 865       fputs (string, stderr);
 866       fflush (stderr);
 867     }
 868   g_free (string);
 869 }
 870
 871 #ifndef MB_LEN_MAX
 872 #  define MB_LEN_MAX 8
 873 #endif
 874
 875 #ifndef HAVE_C99_VSNPRINTF
 876
 877 typedef struct
 878 {
 879   guint min_width;
 880   guint precision;
 881   gboolean alternate_format, zero_padding, adjust_left, locale_grouping;
 882   gboolean add_space, add_sign, possible_sign, seen_precision;
 883   gboolean mod_half, mod_long, mod_extra_long;
 884 } PrintfArgSpec;
 885
 886 static gsize
 887 printf_string_upper_bound (const gchar *format,
 888                            gboolean     may_warn,
 889                            va_list      args)
 890 {
 891   static const gboolean honour_longs = SIZEOF_LONG > 4 || SIZEOF_VOID_P > 4;
 892   gsize len = 1;
 893
 894   if (!format)
 895     return len;
 896
 897   while (*format)
 898     {
 899       register gchar c = *format++;
 900
 901       if (c != '%')
 902         len += 1;
 903       else /* (c == '%') */
 904         {
 905           PrintfArgSpec spec = { 0, };
 906           gboolean seen_l = FALSE, conv_done = FALSE;
 907           gsize conv_len = 0;
 908           const gchar *spec_start = format;
 909
 910           do
 911             {
 912               c = *format++;
 913               switch (c)
 914                 {
 915                   GDoubleIEEE754 u_double;
 916                   guint v_uint;
 917                   gint v_int;
 918                   const gchar *v_string;
 919
 920                   /* beware of positional parameters
 921                    */
 922                 case '$':
 923                   if (may_warn)
 924                     g_warning (G_GNUC_PRETTY_FUNCTION
 925                                "(): unable to handle positional parameters (%%n$)");
 926                   len += 1024; /* try adding some safety padding */
 927                   conv_done = TRUE;
 928                   break;
 929
 930                   /* parse flags
 931                    */
 932                 case '#':
 933                   spec.alternate_format = TRUE;
 934                   break;
 935                 case '0':
 936                   spec.zero_padding = TRUE;
 937                   break;
 938                 case '-':
 939                   spec.adjust_left = TRUE;
 940                   break;
 941                 case ' ':
 942                   spec.add_space = TRUE;
 943                   break;
 944                 case '+':
 945                   spec.add_sign = TRUE;
 946                   break;
 947                 case '\'':
 948                   spec.locale_grouping = TRUE;
 949                   break;
 950
 951                   /* parse output size specifications
 952                    */
 953                 case '.':
 954                   spec.seen_precision = TRUE;
 955                   break;
 956                 case '1':
 957                 case '2':
 958                 case '3':
 959                 case '4':
 960                 case '5':
 961                 case '6':
 962                 case '7':
 963                 case '8':
 964                 case '9':
 965                   v_uint = c - '0';
 966                   c = *format;
 967                   while (c >= '0' && c <= '9')
 968                     {
 969                       format++;
 970                       v_uint = v_uint * 10 + c - '0';
 971                       c = *format;
 972                     }
 973                   if (spec.seen_precision)
 974                     spec.precision = MAX (spec.precision, v_uint);
 975                   else
 976                     spec.min_width = MAX (spec.min_width, v_uint);
 977                   break;
 978                 case '*':
 979                   v_int = va_arg (args, int);
 980                   if (spec.seen_precision)
 981                     {
 982                       /* forget about negative precision */
 983                       if (v_int >= 0)
 984                         spec.precision = MAX (spec.precision, v_int);
 985                     }
 986                   else
 987                     {
 988                       if (v_int < 0)
 989                         {
 990                           v_int = - v_int;
 991                           spec.adjust_left = TRUE;
 992                         }
 993                       spec.min_width = MAX (spec.min_width, v_int);
 994                     }
 995                   break;
 996
 997                   /* parse type modifiers
 998                    */
 999                 case 'h':
1000                   spec.mod_half = TRUE;
1001                   break;
1002                 case 'l':
1003                   if (!seen_l)
1004                     {
1005                       spec.mod_long = TRUE;
1006                       seen_l = TRUE;
1007                       break;
1008                     }
1009                   /* else, fall through */
1010                 case 'L':
1011                 case 'q':
1012                   spec.mod_long = TRUE;
1013                   spec.mod_extra_long = TRUE;
1014                   break;
1015                 case 'z':
1016                 case 'Z':
1017 #if GLIB_SIZEOF_SIZE_T > 4
1018                   spec.mod_long = TRUE;
1019                   spec.mod_extra_long = TRUE;
1020 #endif /* GLIB_SIZEOF_SIZE_T > 4 */
1021                   break;
1022                 case 't':
1023 #if GLIB_SIZEOF_PTRDIFF_T > 4
1024                   spec.mod_long = TRUE;
1025                   spec.mod_extra_long = TRUE;
1026 #endif /* GLIB_SIZEOF_PTRDIFF_T > 4 */
1027                   break;
1028                 case 'j':
1029 #if GLIB_SIZEOF_INTMAX_T > 4
1030                   spec.mod_long = TRUE;
1031                   spec.mod_extra_long = TRUE;
1032 #endif /* GLIB_SIZEOF_INTMAX_T > 4 */
1033                   break;
1034
1035                   /* parse output conversions
1036                    */
1037                 case '%':
1038                   conv_len += 1;
1039                   break;
1040                 case 'O':
1041                 case 'D':
1042                 case 'I':
1043                 case 'U':
1044                   /* some C libraries feature long variants for these as well? */
1045                   spec.mod_long = TRUE;
1046                   /* fall through */
1047                 case 'o':
1048                   conv_len += 2;
1049                   /* fall through */
1050                 case 'd':
1051                 case 'i':
1052                   conv_len += 1; /* sign */
1053                   /* fall through */
1054                 case 'u':
1055                   conv_len += 4;
1056                   /* fall through */
1057                 case 'x':
1058                 case 'X':
1059                   spec.possible_sign = TRUE;
1060                   conv_len += 10;
1061                   if (spec.mod_long && honour_longs)
1062                     conv_len *= 2;
1063                   if (spec.mod_extra_long)
1064                     conv_len *= 2;
1065                   if (spec.mod_extra_long)
1066                     {
1067                       (void) va_arg (args, gint64);
1068                     }
1069                   else if (spec.mod_long)
1070                     (void) va_arg (args, long);
1071                   else
1072                     (void) va_arg (args, int);
1073                   break;
1074                 case 'A':
1075                 case 'a':
1076                   /*          0x */
1077                   conv_len += 2;
1078                   /* fall through */
1079                 case 'g':
1080                 case 'G':
1081                 case 'e':
1082                 case 'E':
1083                 case 'f':
1084                   spec.possible_sign = TRUE;
1085                   /*          n   .   dddddddddddddddddddddddd   E   +-  eeee */
1086                   conv_len += 1 + 1 + MAX (24, spec.precision) + 1 + 1 + 4;
1087                   if (may_warn && spec.mod_extra_long)
1088                     g_warning (G_GNUC_PRETTY_FUNCTION
1089                                "(): unable to handle long double, collecting double only");
1090 #ifdef HAVE_LONG_DOUBLE
1091 #error need to implement special handling for long double
1092 #endif
1093                   u_double.v_double = va_arg (args, double);
1094                   /* %f can expand up to all significant digits before '.' (308) */
1095                   if (c == 'f' &&
1096                       u_double.mpn.biased_exponent > 0 && u_double.mpn.biased_exponent < 2047)
1097                     {
1098                       gint exp = u_double.mpn.biased_exponent;
1099
1100                       exp -= G_IEEE754_DOUBLE_BIAS;
1101                       exp = exp * G_LOG_2_BASE_10 + 1;
1102                       conv_len += ABS (exp);    /* exp can be <0 */
1103                     }
1104                   /* some printf() implementations require extra padding for rounding */
1105                   conv_len += 2;
1106                   /* we can't really handle locale specific grouping here */
1107                   if (spec.locale_grouping)
1108                     conv_len *= 2;
1109                   break;
1110                 case 'C':
1111                   spec.mod_long = TRUE;
1112                   /* fall through */
1113                 case 'c':
1114                   conv_len += spec.mod_long ? MB_LEN_MAX : 1;
1115                   (void) va_arg (args, int);
1116                   break;
1117                 case 'S':
1118                   spec.mod_long = TRUE;
1119                   /* fall through */
1120                 case 's':
1121                   v_string = va_arg (args, char*);
1122                   if (!v_string)
1123                     conv_len += 8; /* hold "(null)" */
1124                   else if (spec.seen_precision)
1125                     conv_len += spec.precision;
1126                   else
1127                     conv_len += strlen (v_string);
1128                   conv_done = TRUE;
1129                   if (spec.mod_long)
1130                     {
1131                       if (may_warn)
1132                         g_warning (G_GNUC_PRETTY_FUNCTION
1133                                    "(): unable to handle wide char strings");
1134                       len += 1024; /* try adding some safety padding */
1135                     }
1136                   break;
1137                 case 'P': /* do we actually need this? */
1138                   /* fall through */
1139                 case 'p':
1140                   spec.alternate_format = TRUE;
1141                   conv_len += 10;
1142                   if (honour_longs)
1143                     conv_len *= 2;
1144                   /* fall through */
1145                 case 'n':
1146                   conv_done = TRUE;
1147                   (void) va_arg (args, void*);
1148                   break;
1149                 case 'm':
1150                   /* there's not much we can do to be clever */
1151                   v_string = g_strerror (errno);
1152                   v_uint = v_string ? strlen (v_string) : 0;
1153                   conv_len += MAX (256, v_uint);
1154                   break;
1155
1156                   /* handle invalid cases
1157                    */
1158                 case '\000':
1159                   /* no conversion specification, bad bad */
1160                   conv_len += format - spec_start;
1161                   break;
1162                 default:
1163                   if (may_warn)
1164                     g_warning (G_GNUC_PRETTY_FUNCTION
1165                                "(): unable to handle `%c' while parsing format",
1166                                c);
1167                   break;
1168                 }
1169               conv_done |= conv_len > 0;
1170             }
1171           while (!conv_done);
1172           /* handle width specifications */
1173           conv_len = MAX (conv_len, MAX (spec.precision, spec.min_width));
1174           /* handle flags */
1175           conv_len += spec.alternate_format ? 2 : 0;
1176           conv_len += (spec.add_space || spec.add_sign || spec.possible_sign);
1177           /* finally done */
1178           len += conv_len;
1179         } /* else (c == '%') */
1180     } /* while (*format) */
1181
1182   return len;
1183 }
1184
1185 #endif /* !HAVE_C99_VSNPRINTF */
1186
1187
1188 gsize
1189 g_printf_string_upper_bound (const gchar *format,
1190                              va_list      args)
1191 {
1192 #if HAVE_C99_VSNPRINTF
1193   gchar c;
1194   return vsnprintf (&c, 1, format, args) + 1;
1195 #else
1196   return printf_string_upper_bound (format, TRUE, args);
1197 #endif
1198 }
1199
1200 void
1201 g_messages_init (void)
1202 {
1203   g_messages_lock = g_mutex_new ();
1204   g_log_depth = g_private_new (NULL);
1205   g_messages_prefixed_init ();
1206   _g_debug_init ();
1207 }
1208
1209 gboolean _g_debug_initialized = FALSE;
1210 guint _g_debug_flags = 0;
1211
1212 void
1213 _g_debug_init (void)
1214 {
1215   const gchar *val;
1216
1217   _g_debug_initialized = TRUE;
1218
1219   val = g_getenv ("G_DEBUG");
1220   if (val != NULL)
1221     {
1222       static const GDebugKey keys[] = {
1223         {"fatal_warnings", G_DEBUG_FATAL_WARNINGS}
1224       };
1225
1226       _g_debug_flags = g_parse_debug_string (val, keys, G_N_ELEMENTS (keys));
1227     }
1228
1229   if (_g_debug_flags & G_DEBUG_FATAL_WARNINGS)
1230     {
1231       GLogLevelFlags fatal_mask;
1232
1233       fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
1234       fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
1235       g_log_set_always_fatal (fatal_mask);
1236     }
1237 }