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

#define _GNU_SOURCE		/* For stpcpy */

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <locale.h>

#include <errno.h>

#include <ctype.h>		/* For tolower() */

#if !defined (HAVE_STRSIGNAL) || !defined(NO_SYS_SIGLIST_DECL)

#include <signal.h>

#endif

#include "glib.h"

#include "gprintf.h"

#include "gprintfint.h"

#include "glibintl.h"

#include "galias.h"

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

#ifdef G_OS_WIN32

#include <windows.h>

#endif

/* do not include <unistd.h> in this place since it

 * interferes with g_strsignal() on some OSes

 */

static const guint16 ascii_table_data[256] = {

  0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,

  0x004, 0x104, 0x104, 0x004, 0x104, 0x104, 0x004, 0x004,

  0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,

  0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,

  0x140, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,

  0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,

  0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,

  0x459, 0x459, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,

  0x0d0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,

  0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,

  0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,

  0x253, 0x253, 0x253, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,

  0x0d0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,

  0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,

  0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,

  0x073, 0x073, 0x073, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x004

  /* the upper 128 are all zeroes */

};

const guint16 * const g_ascii_table = ascii_table_data;

#ifdef __SYMBIAN32__

EXPORT_C const guint16 * const * _g_ascii_table()

{

	return &g_ascii_table;

}

#endif /* __SYMBIAN32__ */

/**

 * g_strdup:

 * @str: the string to duplicate

 *

 * Duplicates a string. If @str is %NULL it returns %NULL.

 * The returned string should be freed with g_free() 

 * when no longer needed.

 * 

 * Returns: a newly-allocated copy of @str

 */

EXPORT_C gchar*

g_strdup (const gchar *str)

{

  gchar *new_str;

  gsize length;

  if (str)

    {

      length = strlen (str) + 1;

      new_str = g_new (char, length);

      memcpy (new_str, str, length);

    }

  else

    new_str = NULL;

  return new_str;

}

EXPORT_C gpointer

g_memdup (gconstpointer mem,

	  guint         byte_size)

{

  gpointer new_mem;

  if (mem)

    {

      new_mem = g_malloc (byte_size);

      memcpy (new_mem, mem, byte_size);

    }

  else

    new_mem = NULL;

  return new_mem;

}

/**

 * g_strndup:

 * @str: the string to duplicate

 * @n: the maximum number of bytes to copy from @str

 *

 * Duplicates the first @n bytes of a string, returning a newly-allocated

 * buffer @n + 1 bytes long which will always be nul-terminated.

 * If @str is less than @n bytes long the buffer is padded with nuls.

 * If @str is %NULL it returns %NULL.

 * The returned value should be freed when no longer needed.

 * 

 * <note><para>

 * To copy a number of characters from a UTF-8 encoded string, use

 * g_utf8_strncpy() instead.

 * </para></note>

 * 

 * Returns: a newly-allocated buffer containing the first @n bytes 

 *          of @str, nul-terminated 

 */

EXPORT_C gchar*

g_strndup (const gchar *str,

	   gsize        n)    

{

  gchar *new_str;

  if (str)

    {

      new_str = g_new (gchar, n + 1);

      strncpy (new_str, str, n);

      new_str[n] = '\0';

    }

  else

    new_str = NULL;

  return new_str;

}

/**

 * g_strnfill:

 * @length: the length of the new string

 * @fill_char: the byte to fill the string with

 *

 * Creates a new string @length bytes long filled with @fill_char.

 * The returned string should be freed when no longer needed.

 * 

 * Returns: a newly-allocated string filled the @fill_char

 */

EXPORT_C gchar*

g_strnfill (gsize length,     

	    gchar fill_char)

{

  gchar *str;

  str = g_new (gchar, length + 1);

  memset (str, (guchar)fill_char, length);

  str[length] = '\0';

  return str;

}

/**

 * g_stpcpy:

 * @dest: destination buffer.

 * @src: source string.

 * 

 * Copies a nul-terminated string into the dest buffer, include the

 * trailing nul, and return a pointer to the trailing nul byte.

 * This is useful for concatenating multiple strings together

 * without having to repeatedly scan for the end.

 * 

 * Return value: a pointer to trailing nul byte.

 **/

EXPORT_C gchar *

g_stpcpy (gchar       *dest,

          const gchar *src)

{

#ifdef HAVE_STPCPY

  g_return_val_if_fail (dest != NULL, NULL);

  g_return_val_if_fail (src != NULL, NULL);

  return stpcpy (dest, src);

#else

  register gchar *d = dest;

  register const gchar *s = src;

  g_return_val_if_fail (dest != NULL, NULL);

  g_return_val_if_fail (src != NULL, NULL);

  do

    *d++ = *s;

  while (*s++ != '\0');

  return d - 1;

#endif

}

/**

 * g_strdup_vprintf:

 * @format: a standard printf() format string, but notice

 *     <link linkend="string-precision">string precision pitfalls</link>

 * @args: the list of parameters to insert into the format string

 * 

 * Similar to the standard C vsprintf() function but safer, since it 

 * calculates the maximum space required and allocates memory to hold 

 * the result. The returned string should be freed with g_free() when 

 * no longer needed.

 *

 * See also g_vasprintf(), which offers the same functionality, but 

 * additionally returns the length of the allocated string.

 *

 * Returns: a newly-allocated string holding the result

 */

EXPORT_C gchar*

g_strdup_vprintf (const gchar *format,

		  va_list      args)

{

  gchar *string = NULL;

  g_vasprintf (&string, format, args);

  return string;

}

/**

 * g_strdup_printf:

 * @format: a standard printf() format string, but notice

 *     <link linkend="string-precision">string precision pitfalls</link>

 * @Varargs: the parameters to insert into the format string

 *

 * Similar to the standard C sprintf() function but safer, since it 

 * calculates the maximum space required and allocates memory to hold 

 * the result. The returned string should be freed with g_free() when no 

 * longer needed.

 * 

 * Returns: a newly-allocated string holding the result

 */

EXPORT_C gchar*

g_strdup_printf (const gchar *format,

		 ...)

{

  gchar *buffer;

  va_list args;

  va_start (args, format);

  buffer = g_strdup_vprintf (format, args);

  va_end (args);

  return buffer;

}

/**

 * g_strconcat:

 * @string1: the first string to add, which must not be %NULL

 * @Varargs: a %NULL-terminated list of strings to append to the string

 * 

 * Concatenates all of the given strings into one long string.

 * The returned string should be freed with g_free() when no longer needed.

 *

 *

 * <warning><para>The variable argument list <emphasis>must</emphasis> end 

 * with %NULL. If you forget the %NULL, g_strconcat() will start appending

 * random memory junk to your string.</para></warning>

 *

 * Returns: a newly-allocated string containing all the string arguments

 */

EXPORT_C gchar*

g_strconcat (const gchar *string1, ...)

{

  gsize	  l;     

  va_list args;

  gchar	  *s;

  gchar	  *concat;

  gchar   *ptr;

  if (!string1)

    return NULL;

  l = 1 + strlen (string1);

  va_start (args, string1);

  s = va_arg (args, gchar*);

  while (s)

    {

      l += strlen (s);

      s = va_arg (args, gchar*);

    }

  va_end (args);

  concat = g_new (gchar, l);

  ptr = concat;

  ptr = g_stpcpy (ptr, string1);

  va_start (args, string1);

  s = va_arg (args, gchar*);

  while (s)

    {

      ptr = g_stpcpy (ptr, s);

      s = va_arg (args, gchar*);

    }

  va_end (args);

  return concat;

}

/**

 * g_strtod:

 * @nptr:    the string to convert to a numeric value.

 * @endptr:  if non-%NULL, it returns the character after

 *           the last character used in the conversion.

 * 

 * Converts a string to a #gdouble value.

 * It calls the standard strtod() function to handle the conversion, but

 * if the string is not completely converted it attempts the conversion

 * again with g_ascii_strtod(), and returns the best match.

 *

 * This function should seldomly be used. The normal situation when reading

 * numbers not for human consumption is to use g_ascii_strtod(). Only when

 * you know that you must expect both locale formatted and C formatted numbers

 * should you use this. Make sure that you don't pass strings such as comma

 * separated lists of values, since the commas may be interpreted as a decimal

 * point in some locales, causing unexpected results.

 * 

 * Return value: the #gdouble value.

 **/

EXPORT_C gdouble

g_strtod (const gchar *nptr,

	  gchar      **endptr)

{

  gchar *fail_pos_1;

  gchar *fail_pos_2;

  gdouble val_1;

  gdouble val_2 = 0;

  g_return_val_if_fail (nptr != NULL, 0);

  fail_pos_1 = NULL;

  fail_pos_2 = NULL;

  val_1 = strtod (nptr, &fail_pos_1);

  if (fail_pos_1 && fail_pos_1[0] != 0)

    val_2 = g_ascii_strtod (nptr, &fail_pos_2);

  if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)

    {

      if (endptr)

	*endptr = fail_pos_1;

      return val_1;

    }

  else

    {

      if (endptr)

	*endptr = fail_pos_2;

      return val_2;

    }

}

/**

 * g_ascii_strtod:

 * @nptr:    the string to convert to a numeric value.

 * @endptr:  if non-%NULL, it returns the character after

 *           the last character used in the conversion.

 * 

 * Converts a string to a #gdouble value.

 *

 * This function behaves like the standard strtod() function

 * does in the C locale. It does this without actually changing 

 * the current locale, since that would not be thread-safe. 

 * A limitation of the implementation is that this function

 * will still accept localized versions of infinities and NANs. 

 *

 * This function is typically used when reading configuration

 * files or other non-user input that should be locale independent.

 * To handle input from the user you should normally use the

 * locale-sensitive system strtod() function.

 *

 * To convert from a #gdouble to a string in a locale-insensitive

 * way, use g_ascii_dtostr().

 *

 * If the correct value would cause overflow, plus or minus %HUGE_VAL

 * is returned (according to the sign of the value), and %ERANGE is

 * stored in %errno. If the correct value would cause underflow,

 * zero is returned and %ERANGE is stored in %errno.

 * 

 * This function resets %errno before calling strtod() so that

 * you can reliably detect overflow and underflow.

 *

 * Return value: the #gdouble value.

 **/

EXPORT_C gdouble

g_ascii_strtod (const gchar *nptr,

		gchar      **endptr)

{

  gchar *fail_pos;

  gdouble val;

  struct lconv *locale_data;

  const char *decimal_point;

  int decimal_point_len;

  const char *p, *decimal_point_pos;

  const char *end = NULL; /* Silence gcc */

  int strtod_errno;

  g_return_val_if_fail (nptr != NULL, 0);

  fail_pos = NULL;

  locale_data = localeconv ();

  decimal_point = locale_data->decimal_point;

  decimal_point_len = strlen (decimal_point);

  g_assert (decimal_point_len != 0);

  decimal_point_pos = NULL;

  end = NULL;

  if (decimal_point[0] != '.' || 

      decimal_point[1] != 0)

    {

      p = nptr;

      /* Skip leading space */

      while (g_ascii_isspace (*p))

	p++;

      /* Skip leading optional sign */

      if (*p == '+' || *p == '-')

	p++;

      if (p[0] == '0' && 

	  (p[1] == 'x' || p[1] == 'X'))

	{

	  p += 2;

	  /* HEX - find the (optional) decimal point */

	  while (g_ascii_isxdigit (*p))

	    p++;

	  if (*p == '.')

	    decimal_point_pos = p++;

	  while (g_ascii_isxdigit (*p))

	    p++;

	  if (*p == 'p' || *p == 'P')

	    p++;

	  if (*p == '+' || *p == '-')

	    p++;

	  while (g_ascii_isdigit (*p))

	    p++;

	  end = p;

	}

      else if (g_ascii_isdigit (*p) || *p == '.')

	{

	  while (g_ascii_isdigit (*p))

	    p++;

	  if (*p == '.')

	    decimal_point_pos = p++;

	  while (g_ascii_isdigit (*p))

	    p++;

	  if (*p == 'e' || *p == 'E')

	    p++;

	  if (*p == '+' || *p == '-')

	    p++;

	  while (g_ascii_isdigit (*p))

	    p++;

	  end = p;

	}

      /* For the other cases, we need not convert the decimal point */

    }

  if (decimal_point_pos)

    {

      char *copy, *c;

      /* We need to convert the '.' to the locale specific decimal point */

      copy = g_malloc (end - nptr + 1 + decimal_point_len);

      c = copy;

      memcpy (c, nptr, decimal_point_pos - nptr);

      c += decimal_point_pos - nptr;

      memcpy (c, decimal_point, decimal_point_len);

      c += decimal_point_len;

      memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1));

      c += end - (decimal_point_pos + 1);

      *c = 0;

      errno = 0;

      val = strtod (copy, &fail_pos);