/* GLIB - Library of useful routines for C programming

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

 *

 * 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.1 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, see <http://www.gnu.org/licenses/>.

 */

/*

 * 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 <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <locale.h>

#include <string.h>

#include <locale.h>

#include <errno.h>

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

#ifdef HAVE_XLOCALE_H

/* Needed on BSD/OS X for e.g. strtod_l */

#include <xlocale.h>

#endif

#ifdef G_OS_WIN32

#include <windows.h>

#endif

/* do not include <unistd.h> here, it may interfere with g_strsignal() */

#include "gstrfuncs.h"

#include "gprintf.h"

#include "gprintfint.h"

#include "glibintl.h"

/**

 * SECTION:string_utils

 * @title: String Utility Functions

 * @short_description: various string-related functions

 *

 * This section describes a number of utility functions for creating,

 * duplicating, and manipulating strings.

 *

 * Note that the functions g_printf(), g_fprintf(), g_sprintf(),

 * g_vprintf(), g_vfprintf(), g_vsprintf() and g_vasprintf()

 * are declared in the header `gprintf.h` which is not included in `glib.h`

 * (otherwise using `glib.h` would drag in `stdio.h`), so you'll have to

 * explicitly include `<glib/gprintf.h>` in order to use the GLib

 * printf() functions.

 *

 * ## String precision pitfalls # {#string-precision}

 *

 * While you may use the printf() functions to format UTF-8 strings,

 * notice that the precision of a \%Ns parameter is interpreted

 * as the number of bytes, not characters to print. On top of that,

 * the GNU libc implementation of the printf() functions has the

 * "feature" that it checks that the string given for the \%Ns

 * parameter consists of a whole number of characters in the current

 * encoding. So, unless you are sure you are always going to be in an

 * UTF-8 locale or your know your text is restricted to ASCII, avoid

 * using \%Ns. If your intention is to format strings for a

 * certain number of columns, then \%Ns is not a correct solution

 * anyway, since it fails to take wide characters (see g_unichar_iswide())

 * into account.

 *

 * Note also that there are various printf() parameters which are platform

 * dependent. GLib provides platform independent macros for these parameters

 * which should be used instead. A common example is %G_GUINT64_FORMAT, which

 * should be used instead of `%llu` or similar parameters for formatting

 * 64-bit integers. These macros are all named `G_*_FORMAT`; see

 * [Basic Types][glib-Basic-Types].

 */

/**

 * g_ascii_isalnum:

 * @c: any character

 *

 * Determines whether a character is alphanumeric.

 *

 * Unlike the standard C library isalnum() function, this only

 * recognizes standard ASCII letters and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to cast to #guchar before

 * passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII alphanumeric character

 */

/**

 * g_ascii_isalpha:

 * @c: any character

 *

 * Determines whether a character is alphabetic (i.e. a letter).

 *

 * Unlike the standard C library isalpha() function, this only

 * recognizes standard ASCII letters and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to cast to #guchar before

 * passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII alphabetic character

 */

/**

 * g_ascii_iscntrl:

 * @c: any character

 *

 * Determines whether a character is a control character.

 *

 * Unlike the standard C library iscntrl() function, this only

 * recognizes standard ASCII control characters and ignores the

 * locale, returning %FALSE for all non-ASCII characters. Also,

 * unlike the standard library function, this takes a char, not

 * an int, so don't call it on %EOF, but no need to cast to #guchar

 * before passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII control character.

 */

/**

 * g_ascii_isdigit:

 * @c: any character

 *

 * Determines whether a character is digit (0-9).

 *

 * Unlike the standard C library isdigit() function, this takes

 * a char, not an int, so don't call it  on %EOF, but no need to

 * cast to #guchar before passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII digit.

 */

/**

 * g_ascii_isgraph:

 * @c: any character

 *

 * Determines whether a character is a printing character and not a space.

 *

 * Unlike the standard C library isgraph() function, this only

 * recognizes standard ASCII characters and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to cast to #guchar before

 * passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII printing character other than space.

 */

/**

 * g_ascii_islower:

 * @c: any character

 *

 * Determines whether a character is an ASCII lower case letter.

 *

 * Unlike the standard C library islower() function, this only

 * recognizes standard ASCII letters and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to worry about casting

 * to #guchar before passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII lower case letter

 */

/**

 * g_ascii_isprint:

 * @c: any character

 *

 * Determines whether a character is a printing character.

 *

 * Unlike the standard C library isprint() function, this only

 * recognizes standard ASCII characters and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to cast to #guchar before

 * passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII printing character.

 */

/**

 * g_ascii_ispunct:

 * @c: any character

 *

 * Determines whether a character is a punctuation character.

 *

 * Unlike the standard C library ispunct() function, this only

 * recognizes standard ASCII letters and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to cast to #guchar before

 * passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII punctuation character.

 */

/**

 * g_ascii_isspace:

 * @c: any character

 *

 * Determines whether a character is a white-space character.

 *

 * Unlike the standard C library isspace() function, this only

 * recognizes standard ASCII white-space and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to cast to #guchar before

 * passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII white-space character

 */

/**

 * g_ascii_isupper:

 * @c: any character

 *

 * Determines whether a character is an ASCII upper case letter.

 *

 * Unlike the standard C library isupper() function, this only

 * recognizes standard ASCII letters and ignores the locale,

 * returning %FALSE for all non-ASCII characters. Also, unlike

 * the standard library function, this takes a char, not an int,

 * so don't call it on %EOF, but no need to worry about casting

 * to #guchar before passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII upper case letter

 */

/**

 * g_ascii_isxdigit:

 * @c: any character

 *

 * Determines whether a character is a hexadecimal-digit character.

 *

 * Unlike the standard C library isxdigit() function, this takes

 * a char, not an int, so don't call it on %EOF, but no need to

 * cast to #guchar before passing a possibly non-ASCII character in.

 *

 * Returns: %TRUE if @c is an ASCII hexadecimal-digit character.

 */

/**

 * G_ASCII_DTOSTR_BUF_SIZE:

 *

 * A good size for a buffer to be passed into g_ascii_dtostr().

 * It is guaranteed to be enough for all output of that function

 * on systems with 64bit IEEE-compatible doubles.

 *

 * The typical usage would be something like:

 * |[ 

 *   char buf[G_ASCII_DTOSTR_BUF_SIZE];

 *

 *   fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));

 * ]|

 */

/**

 * g_strstrip:

 * @string: a string to remove the leading and trailing whitespace from

 *

 * Removes leading and trailing whitespace from a string.

 * See g_strchomp() and g_strchug().

 *

 * Returns: @string

 */

/**

 * G_STR_DELIMITERS:

 *

 * The standard delimiters, used in g_strdelimit().

 */

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;

#if defined (HAVE_NEWLOCALE) && \

    defined (HAVE_USELOCALE) && \

    defined (HAVE_STRTOD_L) && \

    defined (HAVE_STRTOULL_L) && \

    defined (HAVE_STRTOLL_L)

#define USE_XLOCALE 1

#endif

#ifdef USE_XLOCALE

static locale_t

get_C_locale (void)

{

  static gsize initialized = FALSE;

  static locale_t C_locale = NULL;

  if (g_once_init_enter (&initialized))

    {

      C_locale = newlocale (LC_ALL_MASK, "C", NULL);

      g_once_init_leave (&initialized, TRUE);

    }

  return C_locale;

}

#endif

/**

 * g_strdup:

 * @str: (nullable): 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

 */

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;

}

/**

 * g_memdup:

 * @mem: the memory to copy.

 * @byte_size: the number of bytes to copy.

 *

 * Allocates @byte_size bytes of memory, and copies @byte_size bytes into it

 * from @mem. If @mem is %NULL it returns %NULL.

 *

 * Returns: a pointer to the newly-allocated copy of the memory, or %NULL if @mem

 *  is %NULL.

 */

gpointer

g_memdup (gconstpointer mem,

          guint         byte_size)

{

  gpointer new_mem;

  if (mem && byte_size != 0)

    {

      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.

 *

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

 * use g_utf8_strncpy() instead.

 *

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

 *     of @str, nul-terminated

 */

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

 */

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.

 *

 * Returns: a pointer to trailing nul byte.

 **/

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

  gchar *d = dest;

  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

 *     [string precision pitfalls][string-precision]

 * @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

 */

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

 *     [string precision pitfalls][string-precision]

 * @...: 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

 */

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

 * @...: 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.

 *

 * The variable argument list must end with %NULL. If you forget the %NULL,

 * g_strconcat() will start appending random memory junk to your string.

 *

 * Note that this function is usually not the right function to use to

 * assemble a translated message from pieces, since proper translation

 * often requires the pieces to be reordered.

 *

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

 */

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:  (out) (transfer none) (optional): 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 seldom 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.

 *

 * Returns: the #gdouble value.

 **/

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:  (out) (transfer none) (optional): 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.

 *

 * Returns: the #gdouble value.

 */

gdouble

g_ascii_strtod (const gchar *nptr,

                gchar      **endptr)

{

#ifdef USE_XLOCALE

  g_return_val_if_fail (nptr != NULL, 0);

  errno = 0;

  return strtod_l (nptr, endptr, get_C_locale ());

#else

  gchar *fail_pos;

  gdouble val;

#ifndef __BIONIC__

  struct lconv *locale_data;

#endif

  const char *decimal_point;

  gsize 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;

#ifndef __BIONIC__

  locale_data = localeconv ();

  decimal_point = locale_data->decimal_point;

  decimal_point_len = strlen (decimal_point);

#else

  decimal_point = ".";

  decimal_point_len = 1;

#endif

  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);

      strtod_errno = errno;

      if (fail_pos)

        {

          if (fail_pos - copy > decimal_point_pos - nptr)

            fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);

          else

            fail_pos = (char *)nptr + (fail_pos - copy);

        }

      g_free (copy);

    }

  else if (end)

    {

      char *copy;

      copy = g_malloc (end - (char *)nptr + 1);

      memcpy (copy, nptr, end - nptr);

      *(copy + (end - (char *)nptr)) = 0;

      errno = 0;

      val = strtod (copy, &fail_pos);

      strtod_errno = errno;

      if (fail_pos)

        {

          fail_pos = (char *)nptr + (fail_pos - copy);

        }

      g_free (copy);

    }

  else

    {

      errno = 0;

      val = strtod (nptr, &fail_pos);

      strtod_errno = errno;

    }

  if (endptr)

    *endptr = fail_pos;

  errno = strtod_errno;

  return val;

#endif

}

/**

 * g_ascii_dtostr:

 * @buffer: A buffer to place the resulting string in

 * @buf_len: The length of the buffer.

 * @d: The #gdouble to convert

 *

 * Converts a #gdouble to a string, using the '.' as

 * decimal point.

 *

 * This function generates enough precision that converting

 * the string back using g_ascii_strtod() gives the same machine-number

 * (on machines with IEEE compatible 64bit doubles). It is

 * guaranteed that the size of the resulting string will never

 * be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes, including the terminating

 * nul character, which is always added.

 *

 * Returns: The pointer to the buffer with the converted string.

 **/

gchar *

g_ascii_dtostr (gchar       *buffer,

                gint         buf_len,

                gdouble      d)

{

  return g_ascii_formatd (buffer, buf_len, "%.17g", d);

}