/* GLIB - Library of useful routines for C programming

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

 * Portions copyright (c) 2006 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 for the unix part, FIXME: make the win32 part MT safe as well.

 */

#include "config.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <locale.h>

#include <string.h>

#include <errno.h>

#ifdef HAVE_PWD_H

#include <pwd.h>

#endif

#include <sys/types.h>

#ifdef HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif

#ifdef HAVE_CRT_EXTERNS_H 

#include <crt_externs.h> /* for _NSGetEnviron */

#endif

/* implement gutils's inline functions

 */

#define	G_IMPLEMENT_INLINES 1

#define	__G_UTILS_C__

#include "glib.h"

#include "gprintfint.h"

#include "gthreadinit.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glibbackend.h"

#include <glib_wsd.h>

#define G_MALLOC_VOID(numbytes , var) { \

	if(numbytes) \

	{ \

		var = g_try_malloc(numbytes); \

		if(!var) \

			return; \

	} \

	else\

		var = NULL;\

}

#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 */

#ifdef	MAXPATHLEN

#define	G_PATH_LENGTH	MAXPATHLEN

#elif	defined (PATH_MAX)

#define	G_PATH_LENGTH	PATH_MAX

#elif   defined (_PC_PATH_MAX)

#define	G_PATH_LENGTH	sysconf(_PC_PATH_MAX)

#else	

#define G_PATH_LENGTH   2048

#endif

#ifdef G_PLATFORM_WIN32

#  define STRICT		/* Strict typing, please */

#  include <windows.h>

#  undef STRICT

#  ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS

#    define GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT 2

#    define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS 4

#  endif

#  include <lmcons.h>		/* For UNLEN */

#endif /* G_PLATFORM_WIN32 */

#ifdef G_OS_WIN32

#  include <direct.h>

#  include <shlobj.h>

   /* older SDK (e.g. msvc 5.0) does not have these*/

#  ifndef CSIDL_INTERNET_CACHE

#    define CSIDL_INTERNET_CACHE 32

#  endif

#  ifndef CSIDL_COMMON_APPDATA

#    define CSIDL_COMMON_APPDATA 35

#  endif

#  ifndef CSIDL_COMMON_DOCUMENTS

#    define CSIDL_COMMON_DOCUMENTS 46

#  endif

#  ifndef CSIDL_PROFILE

#    define CSIDL_PROFILE 40

#  endif

#  include <process.h>

#endif

#ifdef HAVE_CODESET

#include <langinfo.h>

#endif

#ifdef HAVE_BIND_TEXTDOMAIN_CODESET

#include <libintl.h>    //puneet

#endif

const guint glib_major_version = GLIB_MAJOR_VERSION;

const guint glib_minor_version = GLIB_MINOR_VERSION;

const guint glib_micro_version = GLIB_MICRO_VERSION;

const guint glib_interface_age = GLIB_INTERFACE_AGE;

const guint glib_binary_age = GLIB_BINARY_AGE;

#ifdef __SYMBIAN32__

EXPORT_C const  guint *_glib_major_version()

{

	return &glib_major_version;

}

EXPORT_C const  guint *_glib_minor_version()

{

	return &glib_minor_version;

}

EXPORT_C const  guint *_glib_micro_version()

{

	return &glib_micro_version;

}

EXPORT_C const  guint *_glib_interface_age()

{

	return &glib_interface_age;

}

EXPORT_C const  guint *_glib_binary_age()

{

	return &glib_binary_age;

}

#endif /* __SYMBIAN32__ */

#ifdef G_PLATFORM_WIN32

G_WIN32_DLLMAIN_FOR_DLL_NAME (static, dll_name)

#endif

/**

 * glib_check_version:

 * @required_major: the required major version.

 * @required_minor: the required minor version.

 * @required_micro: the required micro version.

 *

 * Checks that the GLib library in use is compatible with the

 * given version. Generally you would pass in the constants

 * #GLIB_MAJOR_VERSION, #GLIB_MINOR_VERSION, #GLIB_MICRO_VERSION

 * as the three arguments to this function; that produces

 * a check that the library in use is compatible with

 * the version of GLib the application or module was compiled

 * against.

 *

 * Compatibility is defined by two things: first the version

 * of the running library is newer than the version

 * @required_major.required_minor.@required_micro. Second

 * the running library must be binary compatible with the

 * version @required_major.required_minor.@required_micro

 * (same major version.)

 *

 * Return value: %NULL if the GLib library is compatible with the

 *   given version, or a string describing the version mismatch.

 *   The returned string is owned by GLib and must not be modified

 *   or freed.

 *

 * Since: 2.6

 **/

EXPORT_C const gchar *

glib_check_version (guint required_major,

                    guint required_minor,

                    guint required_micro)

{

  gint glib_effective_micro = 100 * GLIB_MINOR_VERSION + GLIB_MICRO_VERSION;

  gint required_effective_micro = 100 * required_minor + required_micro;

  if (required_major > GLIB_MAJOR_VERSION)

    return "GLib version too old (major mismatch)";

  if (required_major < GLIB_MAJOR_VERSION)

    return "GLib version too new (major mismatch)";

  if (required_effective_micro < glib_effective_micro - GLIB_BINARY_AGE)

    return "GLib version too new (micro mismatch)";

  if (required_effective_micro > glib_effective_micro)

    return "GLib version too old (micro mismatch)";

  return NULL;

}

#if !defined (HAVE_MEMMOVE) && !defined (HAVE_WORKING_BCOPY)

/**

 * g_memmove: 

 * @dest: the destination address to copy the bytes to.

 * @src: the source address to copy the bytes from.

 * @len: the number of bytes to copy.

 *

 * Copies a block of memory @len bytes long, from @src to @dest.

 * The source and destination areas may overlap.

 *

 * In order to use this function, you must include 

 * <filename>string.h</filename> yourself, because this macro will 

 * typically simply resolve to memmove() and GLib does not include 

 * <filename>string.h</filename> for you.

 */

void 

g_memmove (gpointer      dest, 

	   gconstpointer src, 

	   gulong        len)

{

  gchar* destptr = dest;

  const gchar* srcptr = src;

  if (src + len < dest || dest + len < src)

    {

      bcopy (src, dest, len);

      return;

    }

  else if (dest <= src)

    {

      while (len--)

	*(destptr++) = *(srcptr++);

    }

  else

    {

      destptr += len;

      srcptr += len;

      while (len--)

	*(--destptr) = *(--srcptr);

    }

}

#endif /* !HAVE_MEMMOVE && !HAVE_WORKING_BCOPY */

#ifdef G_OS_WIN32

#undef g_atexit

#endif

/**

 * g_atexit:

 * @func: the function to call on normal program termination.

 * 

 * Specifies a function to be called at normal program termination.

 *

 * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor

 * macro that maps to a call to the atexit() function in the C

 * library. This means that in case the code that calls g_atexit(),

 * i.e. atexit(), is in a DLL, the function will be called when the

 * DLL is detached from the program. This typically makes more sense

 * than that the function is called when the GLib DLL is detached,

 * which happened earlier when g_atexit() was a function in the GLib

 * DLL.

 *

 * The behaviour of atexit() in the context of dynamically loaded

 * modules is not formally specified and varies wildly.

 *

 * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically

 * loaded module which is unloaded before the program terminates might

 * well cause a crash at program exit.

 *

 * Some POSIX systems implement atexit() like Windows, and have each

 * dynamically loaded module maintain an own atexit chain that is

 * called when the module is unloaded.

 *

 * On other POSIX systems, before a dynamically loaded module is

 * unloaded, the registered atexit functions (if any) residing in that

 * module are called, regardless where the code that registered them

 * resided. This is presumably the most robust approach.

 *

 * As can be seen from the above, for portability it's best to avoid

 * calling g_atexit() (or atexit()) except in the main executable of a

 * program.

 */

EXPORT_C void

g_atexit (GVoidFunc func)

{

  gint result;

  const gchar *error = NULL;

  /* keep this in sync with glib.h */

#ifdef	G_NATIVE_ATEXIT

  result = ATEXIT (func);

  if (result)

    error = g_strerror (errno);

#elif defined (HAVE_ATEXIT)

#  ifdef NeXT /* @#%@! NeXTStep */

  result = !atexit ((void (*)(void)) func);

  if (result)

    error = g_strerror (errno);

#  else

  result = atexit ((void (*)(void)) func);

  if (result)

    error = g_strerror (errno);

#  endif /* NeXT */

#elif defined (HAVE_ON_EXIT)

  result = on_exit ((void (*)(int, void *)) func, NULL);

  if (result)

    error = g_strerror (errno);

#else

  result = 0;

  error = "no implementation";

#endif /* G_NATIVE_ATEXIT */

  if (error)

    g_error ("Could not register atexit() function: %s", error);

}

/* Based on execvp() from GNU Libc.

 * Some of this code is cut-and-pasted into gspawn.c

 */

static gchar*

my_strchrnul (const gchar *str, 

	      gchar        c)

{

  gchar *p = (gchar*)str;

  while (*p && (*p != c))

    ++p;

  return p;

}

#ifdef G_OS_WIN32

static gchar *inner_find_program_in_path (const gchar *program);

EXPORT_C gchar*

g_find_program_in_path (const gchar *program)

{

  #ifdef __SYMBIAN32__

  return getProgPath(program);

  #endif /* __SYMBIAN32__ */

  const gchar *last_dot = strrchr (program, '.');

  if (last_dot == NULL ||

      strchr (last_dot, '\\') != NULL ||

      strchr (last_dot, '/') != NULL)

    {

      const gint program_length = strlen (program);

      gchar *pathext = g_build_path (";",

				     ".exe;.cmd;.bat;.com",

				     g_getenv ("PATHEXT"),

				     NULL);

      gchar *p;

      gchar *decorated_program;

      gchar *retval;

      p = pathext;

      do

	{

	  gchar *q = my_strchrnul (p, ';');

	  decorated_program = g_malloc (program_length + (q-p) + 1);

	  memcpy (decorated_program, program, program_length);

	  memcpy (decorated_program+program_length, p, q-p);

	  decorated_program [program_length + (q-p)] = '\0';

	  retval = inner_find_program_in_path (decorated_program);

	  g_free (decorated_program);

	  if (retval != NULL)

	    {

	      g_free (pathext);

	      return retval;

	    }

	  p = q;

	} while (*p++ != '\0');

      g_free (pathext);

      return NULL;

    }

  else

    return inner_find_program_in_path (program);

}

#endif

/**

 * g_find_program_in_path:

 * @program: a program name in the GLib file name encoding

 * 

 * Locates the first executable named @program in the user's path, in the

 * same way that execvp() would locate it. Returns an allocated string

 * with the absolute path name, or %NULL if the program is not found in

 * the path. If @program is already an absolute path, returns a copy of

 * @program if @program exists and is executable, and %NULL otherwise.

 *  

 * On Windows, if @program does not have a file type suffix, tries

 * with the suffixes .exe, .cmd, .bat and .com, and the suffixes in

 * the <envar>PATHEXT</envar> environment variable. 

 * 

 * On Windows, it looks for the file in the same way as CreateProcess() 

 * would. This means first in the directory where the executing

 * program was loaded from, then in the current directory, then in the

 * Windows 32-bit system directory, then in the Windows directory, and

 * finally in the directories in the <envar>PATH</envar> environment 

 * variable. If the program is found, the return value contains the 

 * full name including the type suffix.

 *

 * Return value: absolute path, or %NULL

 **/

#ifdef G_OS_WIN32

static gchar *

inner_find_program_in_path (const gchar *program)

#else

EXPORT_C gchar*

g_find_program_in_path (const gchar *program)

#endif

{  

  const gchar *path, *p;

  gchar *name, *freeme;

#ifdef G_OS_WIN32

  const gchar *path_copy;

  gchar *filename = NULL, *appdir = NULL;

  gchar *sysdir = NULL, *windir = NULL;

#endif

  size_t len;

  size_t pathlen;

  g_return_val_if_fail (program != NULL, NULL);

#ifdef __SYMBIAN32__

  return getProgPath((char *)program);

#endif /* __SYMBIAN32__ */

  /* If it is an absolute path, or a relative path including subdirectories,

   * don't look in PATH.

   */

  if (g_path_is_absolute (program)

      || strchr (program, G_DIR_SEPARATOR) != NULL

#ifdef G_OS_WIN32

      || strchr (program, '/') != NULL

#endif

      )

    {

      if (g_file_test (program, G_FILE_TEST_IS_EXECUTABLE) &&

	  !g_file_test (program, G_FILE_TEST_IS_DIR))

        return g_strdup (program);

      else

        return NULL;

    }

  path = g_getenv ("PATH");

#if defined(G_OS_UNIX) || defined(G_OS_BEOS)

  if (path == NULL)

    {

      /* There is no `PATH' in the environment.  The default

       * search path in GNU libc is the current directory followed by

       * the path `confstr' returns for `_CS_PATH'.

       */

      /* In GLib we put . last, for security, and don't use the

       * unportable confstr(); UNIX98 does not actually specify

       * what to search if PATH is unset. POSIX may, dunno.

       */

      path = "/bin:/usr/bin:.";

    }

#else

  if (G_WIN32_HAVE_WIDECHAR_API ())

    {

      int n;

      wchar_t wfilename[MAXPATHLEN], wsysdir[MAXPATHLEN],

	wwindir[MAXPATHLEN];

      n = GetModuleFileNameW (NULL, wfilename, MAXPATHLEN);

      if (n > 0 && n < MAXPATHLEN)

	filename = g_utf16_to_utf8 (wfilename, -1, NULL, NULL, NULL);

      n = GetSystemDirectoryW (wsysdir, MAXPATHLEN);

      if (n > 0 && n < MAXPATHLEN)

	sysdir = g_utf16_to_utf8 (wsysdir, -1, NULL, NULL, NULL);

      n = GetWindowsDirectoryW (wwindir, MAXPATHLEN);

      if (n > 0 && n < MAXPATHLEN)

	windir = g_utf16_to_utf8 (wwindir, -1, NULL, NULL, NULL);

    }

  else

    {

      int n;

      gchar cpfilename[MAXPATHLEN], cpsysdir[MAXPATHLEN],

	cpwindir[MAXPATHLEN];

      n = GetModuleFileNameA (NULL, cpfilename, MAXPATHLEN);

      if (n > 0 && n < MAXPATHLEN)

	filename = g_locale_to_utf8 (cpfilename, -1, NULL, NULL, NULL);

      n = GetSystemDirectoryA (cpsysdir, MAXPATHLEN);

      if (n > 0 && n < MAXPATHLEN)

	sysdir = g_locale_to_utf8 (cpsysdir, -1, NULL, NULL, NULL);

      n = GetWindowsDirectoryA (cpwindir, MAXPATHLEN);

      if (n > 0 && n < MAXPATHLEN)

	windir = g_locale_to_utf8 (cpwindir, -1, NULL, NULL, NULL);

    }

  if (filename)

    {

      appdir = g_path_get_dirname (filename);

      g_free (filename);

    }

  path = g_strdup (path);

  if (windir)

    {