/* GLIB - Library of useful routines for C programming

 * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald

 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GLib Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GLib Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GLib at ftp://ftp.gtk.org/pub/gtk/. 

 */

/* 

 * MT safe

 */

#include "config.h"

#include <stdlib.h>

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <signal.h>

#include <locale.h>

#include <errno.h>

#include "glib.h"

#include "gdebug.h"

#include "gprintfint.h"

#include "gthreadprivate.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

#if EMULATOR

#define g_thread_functions_for_glib_use (*_g_thread_functions_for_glib_use())

#define g_thread_use_default_impl (*_g_thread_use_default_impl())

#endif /* EMULATOR */

#if EMULATOR

PLS(_g_debug_initialized ,gmessages,gboolean)

PLS(_g_debug_flags,gmessages,guint)

#define _g_debug_initialized (*FUNCTION_NAME(_g_debug_initialized,gmessages)())

#define _g_debug_flags (*FUNCTION_NAME(_g_debug_flags,gmessages)())

#endif /* EMULATOR */

#ifdef G_OS_WIN32

#include <process.h>		/* For getpid() */

#include <io.h>

#  define STRICT		/* Strict typing, please */

#  define _WIN32_WINDOWS 0x0401 /* to get IsDebuggerPresent */

#  include <windows.h>

#  undef STRICT

#endif

/* --- structures --- */

typedef struct _GLogDomain	GLogDomain;

typedef struct _GLogHandler	GLogHandler;

struct _GLogDomain

{

  gchar		*log_domain;

  GLogLevelFlags fatal_mask;

  GLogHandler	*handlers;

  GLogDomain	*next;

};

struct _GLogHandler

{

  guint		 id;

  GLogLevelFlags log_level;

  GLogFunc	 log_func;

  gpointer	 data;

  GLogHandler	*next;

};

/* --- variables --- */

#if EMULATOR

PLS(g_messages_lock,gmessages,GMutex *)

PLS(g_log_domains,gmessages,GLogDomain *)

PLS(g_log_always_fatal,gmessages,GLogLevelFlags)

PLS(glib_print_func,gmessages,GPrintFunc)

PLS(glib_printerr_func,gmessages,GPrintFunc)

PLS(g_log_depth,gmessages,GPrivate *)

PLS(g_log_msg_prefix,gmessages,GLogLevelFlags)

PLS(default_log_func,gmessages,GLogFunc)

PLS(default_log_data,gmessages,gpointer)

#define g_messages_lock (*FUNCTION_NAME(g_messages_lock,gmessages)())

#define g_log_domains (*FUNCTION_NAME(g_log_domains,gmessages)())

#define g_log_always_fatal (*FUNCTION_NAME(g_log_always_fatal,gmessages)())

#define glib_print_func (*FUNCTION_NAME(glib_print_func,gmessages)())

#define glib_printerr_func (*FUNCTION_NAME(glib_printerr_func,gmessages)())

#define g_log_depth (*FUNCTION_NAME(g_log_depth,gmessages)())

#define g_log_msg_prefix (*FUNCTION_NAME(g_log_msg_prefix,gmessages)())

#define default_log_func (*FUNCTION_NAME(default_log_func,gmessages)())

#define default_log_data (*FUNCTION_NAME(default_log_data,gmessages)())

#else

static GMutex        *g_messages_lock = NULL;

static GLogDomain    *g_log_domains = NULL;

static GLogLevelFlags g_log_always_fatal = G_LOG_FATAL_MASK;

static GPrintFunc     glib_print_func = NULL;

static GPrintFunc     glib_printerr_func = NULL;

static GPrivate	     *g_log_depth = NULL;

static GLogLevelFlags g_log_msg_prefix = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_DEBUG;

static GLogFunc       default_log_func = g_log_default_handler;

static gpointer       default_log_data = NULL;

#endif /* EMULATOR */

/* --- functions --- */

#ifdef G_OS_WIN32

#  define STRICT

#  include <windows.h>

#  undef STRICT

static gboolean win32_keep_fatal_message = FALSE;

/* This default message will usually be overwritten. */

/* Yes, a fixed size buffer is bad. So sue me. But g_error() is never

 * called with huge strings, is it?

 */

static gchar  fatal_msg_buf[1000] = "Unspecified fatal error encountered, aborting.";

static gchar *fatal_msg_ptr = fatal_msg_buf;

#undef write

static inline int

dowrite (int          fd,

	 const void  *buf,

	 unsigned int len)

{

  if (win32_keep_fatal_message)

    {

      memcpy (fatal_msg_ptr, buf, len);

      fatal_msg_ptr += len;

      *fatal_msg_ptr = 0;

      return len;

    }

  write (fd, buf, len);

  return len;

}

#define write(fd, buf, len) dowrite(fd, buf, len)

#endif

static void

write_string (int          fd,

	      const gchar *string)

{

  write (fd, string, strlen (string));

}

#if EMULATOR

PLS(initialized ,g_messages_prefixed_init,gboolean)

#define initialized  (*FUNCTION_NAME(initialized ,g_messages_prefixed_init)())

#endif /* EMULATOR */

static void

g_messages_prefixed_init (void)

{

  #if !(EMULATOR)

  static gboolean initialized = FALSE;

  #endif /* EMULATOR */

  if (!initialized)

    {

      const gchar *val;

      initialized = TRUE;

      val = g_getenv ("G_MESSAGES_PREFIXED");

      if (val)

	{

	  const GDebugKey keys[] = {

	    { "error", G_LOG_LEVEL_ERROR },

	    { "critical", G_LOG_LEVEL_CRITICAL },

	    { "warning", G_LOG_LEVEL_WARNING },

	    { "message", G_LOG_LEVEL_MESSAGE },

	    { "info", G_LOG_LEVEL_INFO },

	    { "debug", G_LOG_LEVEL_DEBUG }

	  };

	  g_log_msg_prefix = g_parse_debug_string (val, keys, G_N_ELEMENTS (keys));

	}

    }

}

#if EMULATOR

#undef initialized

#endif /* EMULATOR */

static GLogDomain*

g_log_find_domain_L (const gchar *log_domain)

{

  register GLogDomain *domain;

  domain = g_log_domains;

  while (domain)

    {

      if (strcmp (domain->log_domain, log_domain) == 0)

	return domain;

      domain = domain->next;

    }

  return NULL;

}

static GLogDomain*

g_log_domain_new_L (const gchar *log_domain)

{

  register GLogDomain *domain;

  domain = g_new (GLogDomain, 1);

  domain->log_domain = g_strdup (log_domain);

  domain->fatal_mask = G_LOG_FATAL_MASK;

  domain->handlers = NULL;

  domain->next = g_log_domains;

  g_log_domains = domain;

  return domain;

}

static void

g_log_domain_check_free_L (GLogDomain *domain)

{

  if (domain->fatal_mask == G_LOG_FATAL_MASK &&

      domain->handlers == NULL)

    {

      register GLogDomain *last, *work;

      last = NULL;  

      work = g_log_domains;

      while (work)

	{

	  if (work == domain)

	    {

	      if (last)

		last->next = domain->next;

	      else

		g_log_domains = domain->next;

	      g_free (domain->log_domain);

	      g_free (domain);

	      break;

	    }

	  last = work;

	  work = last->next;

	}  

    }

}

static GLogFunc

g_log_domain_get_handler_L (GLogDomain	*domain,

			    GLogLevelFlags log_level,

			    gpointer	*data)

{

  if (domain && log_level)

    {

      register GLogHandler *handler;

      handler = domain->handlers;

      while (handler)

	{

	  if ((handler->log_level & log_level) == log_level)

	    {

	      *data = handler->data;

	      return handler->log_func;

	    }

	  handler = handler->next;

	}

    }

  *data = default_log_data;

  return default_log_func;

}

EXPORT_C GLogLevelFlags

g_log_set_always_fatal (GLogLevelFlags fatal_mask)

{

  GLogLevelFlags old_mask;

  /* restrict the global mask to levels that are known to glib

   * since this setting applies to all domains

   */

  fatal_mask &= (1 << G_LOG_LEVEL_USER_SHIFT) - 1;

  /* force errors to be fatal */

  fatal_mask |= G_LOG_LEVEL_ERROR;

  /* remove bogus flag */

  fatal_mask &= ~G_LOG_FLAG_FATAL;

  g_mutex_lock (g_messages_lock);

  old_mask = g_log_always_fatal;

  g_log_always_fatal = fatal_mask;

  g_mutex_unlock (g_messages_lock);

  return old_mask;

}

EXPORT_C GLogLevelFlags

g_log_set_fatal_mask (const gchar   *log_domain,

		      GLogLevelFlags fatal_mask)

{

  GLogLevelFlags old_flags;

  register GLogDomain *domain;

  if (!log_domain)

    log_domain = "";

  /* force errors to be fatal */

  fatal_mask |= G_LOG_LEVEL_ERROR;

  /* remove bogus flag */

  fatal_mask &= ~G_LOG_FLAG_FATAL;

  g_mutex_lock (g_messages_lock);

  domain = g_log_find_domain_L (log_domain);

  if (!domain)

    domain = g_log_domain_new_L (log_domain);

  old_flags = domain->fatal_mask;

  domain->fatal_mask = fatal_mask;

  g_log_domain_check_free_L (domain);

  g_mutex_unlock (g_messages_lock);

  return old_flags;

}

#if EMULATOR

PLS(handler_id,g_log_set_handler,guint)

#define handler_id (*FUNCTION_NAME(handler_id,g_log_set_handler)())

#endif /* EMULATOR */

EXPORT_C guint

g_log_set_handler (const gchar	 *log_domain,

		   GLogLevelFlags log_levels,

		   GLogFunc	  log_func,

		   gpointer	  user_data)

{

  #if !(EMULATOR)

  static guint handler_id = 0;

  #endif /* EMULATOR */

  GLogDomain *domain;

  GLogHandler *handler;

  g_return_val_if_fail ((log_levels & G_LOG_LEVEL_MASK) != 0, 0);

  g_return_val_if_fail (log_func != NULL, 0);

  if (!log_domain)

    log_domain = "";

  handler = g_new (GLogHandler, 1);

  g_mutex_lock (g_messages_lock);

  domain = g_log_find_domain_L (log_domain);

  if (!domain)

    domain = g_log_domain_new_L (log_domain);

  handler->id = ++handler_id;

  handler->log_level = log_levels;

  handler->log_func = log_func;

  handler->data = user_data;

  handler->next = domain->handlers;

  domain->handlers = handler;

  g_mutex_unlock (g_messages_lock);

  return handler_id;

}

#if EMULATOR

#undef handler_id

#endif /* EMULATOR */

EXPORT_C GLogFunc

g_log_set_default_handler (GLogFunc log_func,

			   gpointer user_data)

{

  GLogFunc old_log_func;

  g_mutex_lock (g_messages_lock);

  old_log_func = default_log_func;

  default_log_func = log_func;

  default_log_data = user_data;

  g_mutex_unlock (g_messages_lock);

  return old_log_func;

}

EXPORT_C void

g_log_remove_handler (const gchar *log_domain,

		      guint	   handler_id)

{

  register GLogDomain *domain;

  g_return_if_fail (handler_id > 0);

  if (!log_domain)

    log_domain = "";

  g_mutex_lock (g_messages_lock);

  domain = g_log_find_domain_L (log_domain);

  if (domain)

    {

      GLogHandler *work, *last;

      last = NULL;

      work = domain->handlers;

      while (work)

	{

	  if (work->id == handler_id)

	    {

	      if (last)

		last->next = work->next;

	      else

		domain->handlers = work->next;

	      g_log_domain_check_free_L (domain); 

	      g_mutex_unlock (g_messages_lock);

	      g_free (work);

	      return;

	    }

	  last = work;

	  work = last->next;

	}

    } 

  g_mutex_unlock (g_messages_lock);

  g_warning ("%s: could not find handler with id `%d' for domain \"%s\"",

	     G_STRLOC, handler_id, log_domain);

}

EXPORT_C void

g_logv (const gchar   *log_domain,

	GLogLevelFlags log_level,

	const gchar   *format,

	va_list	       args1)

{

  gboolean was_fatal = (log_level & G_LOG_FLAG_FATAL) != 0;

  gboolean was_recursion = (log_level & G_LOG_FLAG_RECURSION) != 0;

  gint i;

  log_level &= G_LOG_LEVEL_MASK;

  if (!log_level)

    return;

  for (i = g_bit_nth_msf (log_level, -1); i >= 0; i = g_bit_nth_msf (log_level, i))

    {

      register GLogLevelFlags test_level;

      test_level = 1 << i;

      if (log_level & test_level)

	{

	  guint depth = GPOINTER_TO_UINT (g_private_get (g_log_depth));

	  GLogDomain *domain;

	  GLogFunc log_func;

	  GLogLevelFlags domain_fatal_mask;

	  gpointer data = NULL;

	  if (was_fatal)

	    test_level |= G_LOG_FLAG_FATAL;

	  if (was_recursion)

	    test_level |= G_LOG_FLAG_RECURSION;

	  /* check recursion and lookup handler */

	  g_mutex_lock (g_messages_lock);

	  domain = g_log_find_domain_L (log_domain ? log_domain : "");

	  if (depth)

	    test_level |= G_LOG_FLAG_RECURSION;

	  depth++;

	  domain_fatal_mask = domain ? domain->fatal_mask : G_LOG_FATAL_MASK;

	  if ((domain_fatal_mask | g_log_always_fatal) & test_level)

	    test_level |= G_LOG_FLAG_FATAL;

	  if (test_level & G_LOG_FLAG_RECURSION)

	    log_func = _g_log_fallback_handler;

	  else

	    log_func = g_log_domain_get_handler_L (domain, test_level, &data);

	  domain = NULL;

	  g_mutex_unlock (g_messages_lock);

	  g_private_set (g_log_depth, GUINT_TO_POINTER (depth));

	  /* had to defer debug initialization until we can keep track of recursion */

	  if (!(test_level & G_LOG_FLAG_RECURSION) && !_g_debug_initialized)

	    {

	      GLogLevelFlags orig_test_level = test_level;

	      _g_debug_init ();

	      if ((domain_fatal_mask | g_log_always_fatal) & test_level)

		test_level |= G_LOG_FLAG_FATAL;

	      if (test_level != orig_test_level)

		{

		  /* need a relookup, not nice, but not too bad either */

		  g_mutex_lock (g_messages_lock);

		  domain = g_log_find_domain_L (log_domain ? log_domain : "");

		  log_func = g_log_domain_get_handler_L (domain, test_level, &data);

		  domain = NULL;

		  g_mutex_unlock (g_messages_lock);