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 Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library 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-1999.  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
  45 #ifdef NATIVE_WIN32
  46 #  define STRICT
  47 #  include <windows.h>
  48 #  include <process.h>          /* For _getpid() */
  49
  50 /* Just use stdio. If we're out of memory, we're hosed anyway. */
  51 #undef write
  52
  53 static inline int
  54 write (FILE       *fd,
  55        const char *buf,
  56        int         len)
  57 {
  58   fwrite (buf, len, 1, fd);
  59
  60   return len;
  61 }
  62
  63 static void
  64 ensure_stdout_valid (void)
  65 {
  66   HANDLE handle;
  67
  68   handle = GetStdHandle (STD_OUTPUT_HANDLE);
  69
  70   if (handle == INVALID_HANDLE_VALUE)
  71     {
  72       AllocConsole ();
  73       freopen ("CONOUT$", "w", stdout);
  74     }
  75 }
  76 #else
  77 #define ensure_stdout_valid()   /* Define as empty */
  78 #endif
  79
  80
  81 /* --- structures --- */
  82 typedef struct _GLogDomain      GLogDomain;
  83 typedef struct _GLogHandler     GLogHandler;
  84 struct _GLogDomain
  85 {
  86   gchar         *log_domain;
  87   GLogLevelFlags fatal_mask;
  88   GLogHandler   *handlers;
  89   GLogDomain    *next;
  90 };
  91 struct _GLogHandler
  92 {
  93   guint          id;
  94   GLogLevelFlags log_level;
  95   GLogFunc       log_func;
  96   gpointer       data;
  97   GLogHandler   *next;
  98 };
  99
 100
 101 /* --- variables --- */
 102
 103 static GMutex* g_messages_lock = NULL;
 104
 105 const gchar          *g_log_domain_glib = "GLib";
 106 static GLogDomain    *g_log_domains = NULL;
 107 static GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;
 108 static GPrintFunc     glib_print_func = NULL;
 109 static GPrintFunc     glib_printerr_func = NULL;
 110 static GErrorFunc     glib_error_func = NULL;
 111 static GWarningFunc   glib_warning_func = NULL;
 112 static GPrintFunc     glib_message_func = NULL;
 113
 114 static GPrivate* g_log_depth = NULL;
 115
 116
 117 /* --- functions --- */
 118 static inline GLogDomain*
 119 g_log_find_domain (const gchar    *log_domain)
 120 {
 121   register GLogDomain *domain;
 122
 123   g_mutex_lock (g_messages_lock);
 124   domain = g_log_domains;
 125   while (domain)
 126     {
 127       if (strcmp (domain->log_domain, log_domain) == 0)
 128         {
 129           g_mutex_unlock (g_messages_lock);
 130           return domain;
 131         }
 132       domain = domain->next;
 133     }
 134   g_mutex_unlock (g_messages_lock);
 135   return NULL;
 136 }
 137
 138 static inline GLogDomain*
 139 g_log_domain_new (const gchar *log_domain)
 140 {
 141   register GLogDomain *domain;
 142
 143   domain = g_new (GLogDomain, 1);
 144   domain->log_domain = g_strdup (log_domain);
 145   domain->fatal_mask = G_LOG_FATAL_MASK;
 146   domain->handlers = NULL;
 147
 148   g_mutex_lock (g_messages_lock);
 149   domain->next = g_log_domains;
 150   g_log_domains = domain;
 151   g_mutex_unlock (g_messages_lock);
 152
 153   return domain;
 154 }
 155
 156 static inline void
 157 g_log_domain_check_free (GLogDomain *domain)
 158 {
 159   if (domain->fatal_mask == G_LOG_FATAL_MASK &&
 160       domain->handlers == NULL)
 161     {
 162       register GLogDomain *last, *work;
 163
 164       last = NULL;
 165
 166       g_mutex_lock (g_messages_lock);
 167       work = g_log_domains;
 168       while (work)
 169         {
 170           if (work == domain)
 171             {
 172               if (last)
 173                 last->next = domain->next;
 174               else
 175                 g_log_domains = domain->next;
 176               g_free (domain->log_domain);
 177               g_free (domain);
 178               break;
 179             }
 180           work = work->next;
 181         }
 182       g_mutex_unlock (g_messages_lock);
 183     }
 184 }
 185
 186 static inline GLogFunc
 187 g_log_domain_get_handler (GLogDomain    *domain,
 188                           GLogLevelFlags log_level,
 189                           gpointer      *data)
 190 {
 191   if (domain && log_level)
 192     {
 193       register GLogHandler *handler;
 194
 195       handler = domain->handlers;
 196       while (handler)
 197         {
 198           if ((handler->log_level & log_level) == log_level)
 199             {
 200               *data = handler->data;
 201               return handler->log_func;
 202             }
 203           handler = handler->next;
 204         }
 205     }
 206   return g_log_default_handler;
 207 }
 208
 209 GLogLevelFlags
 210 g_log_set_always_fatal (GLogLevelFlags fatal_mask)
 211 {
 212   GLogLevelFlags old_mask;
 213
 214   /* restrict the global mask to levels that are known to glib */
 215   fatal_mask &= (1 << G_LOG_LEVEL_USER_SHIFT) - 1;
 216   /* force errors to be fatal */
 217   fatal_mask |= G_LOG_LEVEL_ERROR;
 218   /* remove bogus flag */
 219   fatal_mask &= ~G_LOG_FLAG_FATAL;
 220
 221   g_mutex_lock (g_messages_lock);
 222   old_mask = g_log_always_fatal;
 223   g_log_always_fatal = fatal_mask;
 224   g_mutex_unlock (g_messages_lock);
 225
 226   return old_mask;
 227 }
 228
 229 GLogLevelFlags
 230 g_log_set_fatal_mask (const gchar    *log_domain,
 231                       GLogLevelFlags  fatal_mask)
 232 {
 233   GLogLevelFlags old_flags;
 234   register GLogDomain *domain;
 235
 236   if (!log_domain)
 237     log_domain = "";
 238
 239   /* force errors to be fatal */
 240   fatal_mask |= G_LOG_LEVEL_ERROR;
 241   /* remove bogus flag */
 242   fatal_mask &= ~G_LOG_FLAG_FATAL;
 243
 244   domain = g_log_find_domain (log_domain);
 245   if (!domain)
 246     domain = g_log_domain_new (log_domain);
 247   old_flags = domain->fatal_mask;
 248
 249   domain->fatal_mask = fatal_mask;
 250   g_log_domain_check_free (domain);
 251
 252   return old_flags;
 253 }
 254
 255 guint
 256 g_log_set_handler (const gchar    *log_domain,
 257                    GLogLevelFlags  log_levels,
 258                    GLogFunc        log_func,
 259                    gpointer        user_data)
 260 {
 261   register GLogDomain *domain;
 262   register GLogHandler *handler;
 263   static guint handler_id = 0;
 264
 265   g_return_val_if_fail ((log_levels & G_LOG_LEVEL_MASK) != 0, 0);
 266   g_return_val_if_fail (log_func != NULL, 0);
 267
 268   if (!log_domain)
 269     log_domain = "";
 270
 271   domain = g_log_find_domain (log_domain);
 272   if (!domain)
 273     domain = g_log_domain_new (log_domain);
 274
 275   handler = g_new (GLogHandler, 1);
 276   g_mutex_lock (g_messages_lock);
 277   handler->id = ++handler_id;
 278   g_mutex_unlock (g_messages_lock);
 279   handler->log_level = log_levels;
 280   handler->log_func = log_func;
 281   handler->data = user_data;
 282   handler->next = domain->handlers;
 283   domain->handlers = handler;
 284
 285   return handler_id;
 286 }
 287
 288 void
 289 g_log_remove_handler (const gchar    *log_domain,
 290                       guint           handler_id)
 291 {
 292   register GLogDomain *domain;
 293
 294   g_return_if_fail (handler_id > 0);
 295
 296   if (!log_domain)
 297     log_domain = "";
 298
 299   domain = g_log_find_domain (log_domain);
 300   if (domain)
 301     {
 302       register GLogHandler *work, *last;
 303
 304       last = NULL;
 305       work = domain->handlers;
 306       while (work)
 307         {
 308           if (work->id == handler_id)
 309             {
 310               if (last)
 311                 last->next = work->next;
 312               else
 313                 domain->handlers = work->next;
 314               g_free (work);
 315               g_log_domain_check_free (domain);
 316               return;
 317             }
 318           work = work->next;
 319         }
 320     }
 321   g_warning ("g_log_remove_handler(): could not find handler with id `%d' for domain \"%s\"",
 322              handler_id,
 323              log_domain);
 324 }
 325
 326 void
 327 g_logv (const gchar    *log_domain,
 328         GLogLevelFlags  log_level,
 329         const gchar    *format,
 330         va_list         args1)
 331 {
 332   va_list args2;
 333   gchar buffer[1025];
 334   register gint i;
 335
 336   log_level &= G_LOG_LEVEL_MASK;
 337   if (!log_level)
 338     return;
 339
 340   /* we use a stack buffer of fixed size, because we might get called
 341    * recursively.
 342    */
 343   G_VA_COPY (args2, args1);
 344   if (g_printf_string_upper_bound (format, args1) < 1024)
 345     vsprintf (buffer, format, args2);
 346   else
 347     {
 348       /* since we might be out of memory, we can't use g_vsnprintf(). */
 349 #ifdef  HAVE_VSNPRINTF
 350       vsnprintf (buffer, 1024, format, args2);
 351 #else   /* !HAVE_VSNPRINTF */
 352       /* we are out of luck here */
 353       strncpy (buffer, format, 1024);
 354 #endif  /* !HAVE_VSNPRINTF */
 355       buffer[1024] = 0;
 356     }
 357   va_end (args2);
 358
 359   for (i = g_bit_nth_msf (log_level, -1); i >= 0; i = g_bit_nth_msf (log_level, i))
 360     {
 361       register GLogLevelFlags test_level;
 362
 363       test_level = 1 << i;
 364       if (log_level & test_level)
 365         {
 366           guint depth = GPOINTER_TO_UINT (g_private_get (g_log_depth));
 367           GLogDomain *domain;
 368           GLogFunc log_func;
 369           gpointer data = NULL;
 370
 371           domain = g_log_find_domain (log_domain ? log_domain : "");
 372
 373           if (depth)
 374             test_level |= G_LOG_FLAG_RECURSION;
 375
 376           depth++;
 377           g_private_set (g_log_depth, GUINT_TO_POINTER (depth));
 378
 379           g_mutex_lock (g_messages_lock);
 380           if ((((domain ? domain->fatal_mask : G_LOG_FATAL_MASK) |
 381                 g_log_always_fatal) & test_level) != 0)
 382             test_level |= G_LOG_FLAG_FATAL;
 383           g_mutex_unlock (g_messages_lock);
 384
 385           log_func = g_log_domain_get_handler (domain, test_level, &data);
 386           log_func (log_domain, test_level, buffer, data);
 387
 388           /* *domain can be cluttered now */
 389
 390           if (test_level & G_LOG_FLAG_FATAL)
 391             {
 392 #if defined (G_ENABLE_DEBUG) && defined (SIGTRAP)
 393               if (!(test_level & G_LOG_FLAG_RECURSION))
 394                 raise (SIGTRAP);
 395               else
 396                 abort ();
 397 #else /* !G_ENABLE_DEBUG || !SIGTRAP */
 398               abort ();
 399 #endif /* !G_ENABLE_DEBUG || !SIGTRAP */
 400             }
 401
 402           depth--;
 403           g_private_set (g_log_depth, GUINT_TO_POINTER (depth));
 404         }
 405     }
 406 }
 407
 408 void
 409 g_log (const gchar    *log_domain,
 410        GLogLevelFlags  log_level,
 411        const gchar    *format,
 412        ...)
 413 {
 414   va_list args;
 415
 416   va_start (args, format);
 417   g_logv (log_domain, log_level, format, args);
 418   va_end (args);
 419 }
 420
 421 void
 422 g_log_default_handler (const gchar    *log_domain,
 423                        GLogLevelFlags  log_level,
 424                        const gchar    *message,
 425                        gpointer        unused_data)
 426 {
 427 #ifdef NATIVE_WIN32
 428   FILE *fd;
 429 #else
 430   gint fd;
 431 #endif
 432   gboolean in_recursion;
 433   gboolean is_fatal;
 434   GErrorFunc local_glib_error_func;
 435   GWarningFunc local_glib_warning_func;
 436   GPrintFunc local_glib_message_func;
 437   gchar prg_pid[64], *prg_name = g_get_prgname ();
 438
 439   in_recursion = (log_level & G_LOG_FLAG_RECURSION) != 0;
 440   is_fatal = (log_level & G_LOG_FLAG_FATAL) != 0;
 441   log_level &= G_LOG_LEVEL_MASK;
 442
 443   if (!message)
 444     message = "g_log_default_handler(): (NULL) message";
 445   if (!prg_name)
 446     {
 447       prg_name = "(process";
 448       sprintf (prg_pid, ":%u): ", getpid ());
 449     }
 450   else
 451     sprintf (prg_pid, " (pid:%u): ", getpid ());
 452
 453 #ifdef NATIVE_WIN32
 454   /* Use just stdout as stderr is hard to get redirected from the
 455    * DOS prompt.
 456    */
 457   fd = stdout;
 458 #else
 459   fd = (log_level >= G_LOG_LEVEL_MESSAGE) ? 1 : 2;
 460 #endif
 461
 462   g_mutex_lock (g_messages_lock);
 463   local_glib_error_func = glib_error_func;
 464   local_glib_warning_func = glib_warning_func;
 465   local_glib_message_func = glib_message_func;
 466   g_mutex_unlock (g_messages_lock);
 467
 468   switch (log_level)
 469     {
 470     case G_LOG_LEVEL_ERROR:
 471       if (!log_domain && local_glib_error_func)
 472         {
 473           /* compatibility code */
 474           local_glib_error_func (message);
 475           return;
 476         }
 477       /* use write(2) for output, in case we are out of memeory */
 478       ensure_stdout_valid ();
 479       write (fd, "\n", 1);
 480 #ifdef G_ENABLE_MSG_PREFIX
 481       write (fd, prg_name, strlen (prg_name));
 482       write (fd, prg_pid, strlen (prg_pid));
 483 #endif /* G_ENABLE_MSG_PREFIX */
 484       if (log_domain)
 485         {
 486           write (fd, log_domain, strlen (log_domain));
 487           write (fd, "-", 1);
 488         }
 489       else
 490         write (fd, "** ", 3);
 491       if (in_recursion)
 492         write (fd, "ERROR (recursed) **: ", 21);
 493       else
 494         write (fd, "ERROR **: ", 10);
 495       write (fd, message, strlen (message));
 496       if (is_fatal)
 497         write (fd, "\naborting...\n", 13);
 498       else
 499         write (fd, "\n", 1);
 500       break;
 501     case G_LOG_LEVEL_CRITICAL:
 502       ensure_stdout_valid ();
 503       write (fd, "\n", 1);
 504 #ifdef G_ENABLE_MSG_PREFIX
 505       write (fd, prg_name, strlen (prg_name));
 506       write (fd, prg_pid, strlen (prg_pid));
 507 #endif /* G_ENABLE_MSG_PREFIX */
 508       if (log_domain)
 509         {
 510           write (fd, log_domain, strlen (log_domain));
 511           write (fd, "-", 1);
 512         }
 513       else
 514         write (fd, "** ", 3);
 515       if (in_recursion)
 516         write (fd, "CRITICAL (recursed) **: ", 24);
 517       else
 518         write (fd, "CRITICAL **: ", 13);
 519       write (fd, message, strlen (message));
 520       if (is_fatal)
 521         write (fd, "\naborting...\n", 13);
 522       else
 523         write (fd, "\n", 1);
 524       break;
 525     case G_LOG_LEVEL_WARNING:
 526       if (!log_domain && local_glib_warning_func)
 527         {
 528           /* compatibility code */
 529           local_glib_warning_func (message);
 530           return;
 531         }
 532       ensure_stdout_valid ();
 533       write (fd, "\n", 1);
 534 #ifdef G_ENABLE_MSG_PREFIX
 535       write (fd, prg_name, strlen (prg_name));
 536       write (fd, prg_pid, strlen (prg_pid));
 537 #endif /* G_ENABLE_MSG_PREFIX */
 538       if (log_domain)
 539         {
 540           write (fd, log_domain, strlen (log_domain));
 541           write (fd, "-", 1);
 542         }
 543       else
 544         write (fd, "** ", 3);
 545       if (in_recursion)
 546         write (fd, "WARNING (recursed) **: ", 23);
 547       else
 548         write (fd, "WARNING **: ", 12);
 549       write (fd, message, strlen (message));
 550       if (is_fatal)
 551         write (fd, "\naborting...\n", 13);
 552       else
 553         write (fd, "\n", 1);
 554       break;
 555     case G_LOG_LEVEL_MESSAGE:
 556       if (!log_domain && local_glib_message_func)
 557         {
 558           /* compatibility code */
 559           local_glib_message_func (message);
 560           return;
 561         }
 562       ensure_stdout_valid ();
 563 #ifdef G_ENABLE_MSG_PREFIX
 564       write (fd, prg_name, strlen (prg_name));
 565       write (fd, prg_pid, strlen (prg_pid));
 566 #endif /* G_ENABLE_MSG_PREFIX */
 567       if (log_domain)
 568         {
 569           write (fd, log_domain, strlen (log_domain));
 570           write (fd, "-", 1);
 571         }
 572       if (in_recursion)
 573         write (fd, "Message (recursed): ", 20);
 574       else
 575         write (fd, "Message: ", 9);
 576       write (fd, message, strlen (message));
 577       if (is_fatal)
 578         write (fd, "\naborting...\n", 13);
 579       else
 580         write (fd, "\n", 1);
 581       break;
 582     case G_LOG_LEVEL_INFO:
 583       ensure_stdout_valid ();
 584 #ifdef G_ENABLE_MSG_PREFIX
 585       write (fd, prg_name, strlen (prg_name));
 586       write (fd, prg_pid, strlen (prg_pid));
 587 #endif /* G_ENABLE_MSG_PREFIX */
 588       if (log_domain)
 589         {
 590           write (fd, log_domain, strlen (log_domain));
 591           write (fd, "-", 1);
 592         }
 593       if (in_recursion)
 594         write (fd, "INFO (recursed): ", 17);
 595       else
 596         write (fd, "INFO: ", 6);
 597       write (fd, message, strlen (message));
 598       if (is_fatal)
 599         write (fd, "\naborting...\n", 13);
 600       else
 601         write (fd, "\n", 1);
 602       break;
 603     case G_LOG_LEVEL_DEBUG:
 604       ensure_stdout_valid ();
 605 #ifdef G_ENABLE_MSG_PREFIX
 606       write (fd, prg_name, strlen (prg_name));
 607       write (fd, prg_pid, strlen (prg_pid));
 608 #endif /* G_ENABLE_MSG_PREFIX */
 609       if (log_domain)
 610         {
 611           write (fd, log_domain, strlen (log_domain));
 612           write (fd, "-", 1);
 613         }
 614       if (in_recursion)
 615         write (fd, "DEBUG (recursed): ", 18);
 616       else
 617         write (fd, "DEBUG: ", 7);
 618       write (fd, message, strlen (message));
 619       if (is_fatal)
 620         write (fd, "\naborting...\n", 13);
 621       else
 622         write (fd, "\n", 1);
 623       break;
 624     default:
 625       /* we are used for a log level that is not defined by GLib itself,
 626        * try to make the best out of it.
 627        */
 628       ensure_stdout_valid ();
 629 #ifdef G_ENABLE_MSG_PREFIX
 630       write (fd, prg_name, strlen (prg_name));
 631       write (fd, prg_pid, strlen (prg_pid));
 632 #endif /* G_ENABLE_MSG_PREFIX */
 633       if (log_domain)
 634         {
 635           write (fd, log_domain, strlen (log_domain));
 636           if (in_recursion)
 637             write (fd, "-LOG (recursed:", 15);
 638           else
 639             write (fd, "-LOG (", 6);
 640         }
 641       else if (in_recursion)
 642         write (fd, "LOG (recursed:", 14);
 643       else
 644         write (fd, "LOG (", 5);
 645       if (log_level)
 646         {
 647           gchar string[] = "0x00): ";
 648           gchar *p = string + 2;
 649           guint i;
 650
 651           i = g_bit_nth_msf (log_level, -1);
 652           *p = i >> 4;
 653           p++;
 654           *p = '0' + (i & 0xf);
 655           if (*p > '9')
 656             *p += 'A' - '9' - 1;
 657
 658           write (fd, string, 7);
 659         }
 660       else
 661         write (fd, "): ", 3);
 662       write (fd, message, strlen (message));
 663       if (is_fatal)
 664         write (fd, "\naborting...\n", 13);
 665       else
 666         write (fd, "\n", 1);
 667       break;
 668     }
 669 }
 670
 671 GPrintFunc
 672 g_set_print_handler (GPrintFunc func)
 673 {
 674   GPrintFunc old_print_func;
 675
 676   g_mutex_lock (g_messages_lock);
 677   old_print_func = glib_print_func;
 678   glib_print_func = func;
 679   g_mutex_unlock (g_messages_lock);
 680
 681   return old_print_func;
 682 }
 683
 684 void
 685 g_print (const gchar *format,
 686          ...)
 687 {
 688   va_list args;
 689   gchar *string;
 690   GPrintFunc local_glib_print_func;
 691
 692   g_return_if_fail (format != NULL);
 693
 694   va_start (args, format);
 695   string = g_strdup_vprintf (format, args);
 696   va_end (args);
 697
 698   g_mutex_lock (g_messages_lock);
 699   local_glib_print_func = glib_print_func;
 700   g_mutex_unlock (g_messages_lock);
 701
 702   if (local_glib_print_func)
 703     local_glib_print_func (string);
 704   else
 705     {
 706       ensure_stdout_valid ();
 707       fputs (string, stdout);
 708       fflush (stdout);
 709     }
 710   g_free (string);
 711 }
 712
 713 GPrintFunc
 714 g_set_printerr_handler (GPrintFunc func)
 715 {
 716   GPrintFunc old_printerr_func;
 717
 718   g_mutex_lock (g_messages_lock);
 719   old_printerr_func = glib_printerr_func;
 720   glib_printerr_func = func;
 721   g_mutex_unlock (g_messages_lock);
 722
 723   return old_printerr_func;
 724 }
 725
 726 void
 727 g_printerr (const gchar *format,
 728             ...)
 729 {
 730   va_list args;
 731   gchar *string;
 732   GPrintFunc local_glib_printerr_func;
 733
 734   g_return_if_fail (format != NULL);
 735
 736   va_start (args, format);
 737   string = g_strdup_vprintf (format, args);
 738   va_end (args);
 739
 740   g_mutex_lock (g_messages_lock);
 741   local_glib_printerr_func = glib_printerr_func;
 742   g_mutex_unlock (g_messages_lock);
 743
 744   if (local_glib_printerr_func)
 745     local_glib_printerr_func (string);
 746   else
 747     {
 748       fputs (string, stderr);
 749       fflush (stderr);
 750     }
 751   g_free (string);
 752 }
 753
 754 /* compatibility code */
 755 GErrorFunc
 756 g_set_error_handler (GErrorFunc func)
 757 {
 758   GErrorFunc old_error_func;
 759
 760   g_mutex_lock (g_messages_lock);
 761   old_error_func = glib_error_func;
 762   glib_error_func = func;
 763   g_mutex_unlock (g_messages_lock);
 764
 765   return old_error_func;
 766 }
 767
 768 /* compatibility code */
 769 GWarningFunc
 770 g_set_warning_handler (GWarningFunc func)
 771 {
 772   GWarningFunc old_warning_func;
 773
 774   g_mutex_lock (g_messages_lock);
 775   old_warning_func = glib_warning_func;
 776   glib_warning_func = func;
 777   g_mutex_unlock (g_messages_lock);
 778
 779   return old_warning_func;
 780 }
 781
 782 /* compatibility code */
 783 GPrintFunc
 784 g_set_message_handler (GPrintFunc func)
 785 {
 786   GPrintFunc old_message_func;
 787
 788   g_mutex_lock (g_messages_lock);
 789   old_message_func = glib_message_func;
 790   glib_message_func = func;
 791   g_mutex_unlock (g_messages_lock);
 792
 793   return old_message_func;
 794 }
 795
 796 void
 797 g_messages_init (void)
 798 {
 799   g_messages_lock = g_mutex_new();
 800   g_log_depth = g_private_new(NULL);
 801 }