glib/gstrfuncs.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 Lesser 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser 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-2000.  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 #include "config.h"
  32
  33 #define _GNU_SOURCE             /* For stpcpy */
  34
  35 #include <stdarg.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <locale.h>
  40 #include <errno.h>
  41 #include <ctype.h>              /* For tolower() */
  42 #if !defined (HAVE_STRSIGNAL) || !defined(NO_SYS_SIGLIST_DECL)
  43 #include <signal.h>
  44 #endif
  45
  46 #include "glib.h"
  47 #include "gprintf.h"
  48 #include "gprintfint.h"
  49
  50 #include "galias.h"
  51
  52 #ifdef G_OS_WIN32
  53 #include <windows.h>
  54 #endif
  55
  56 /* do not include <unistd.h> in this place since it
  57  * interferes with g_strsignal() on some OSes
  58  */
  59
  60 static const guint16 ascii_table_data[256] = {
  61   0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
  62   0x004, 0x104, 0x104, 0x004, 0x104, 0x104, 0x004, 0x004,
  63   0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
  64   0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
  65   0x140, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
  66   0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
  67   0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,
  68   0x459, 0x459, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
  69   0x0d0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,
  70   0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
  71   0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
  72   0x253, 0x253, 0x253, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
  73   0x0d0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,
  74   0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
  75   0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
  76   0x073, 0x073, 0x073, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x004
  77   /* the upper 128 are all zeroes */
  78 };
  79
  80 const guint16 * const g_ascii_table = ascii_table_data;
  81
  82 gchar*
  83 g_strdup (const gchar *str)
  84 {
  85   gchar *new_str;
  86   gsize length;
  87
  88   if (str)
  89     {
  90       length = strlen (str) + 1;
  91       new_str = g_new (char, length);
  92       memcpy (new_str, str, length);
  93     }
  94   else
  95     new_str = NULL;
  96
  97   return new_str;
  98 }
  99
 100 gpointer
 101 g_memdup (gconstpointer mem,
 102           guint         byte_size)
 103 {
 104   gpointer new_mem;
 105
 106   if (mem)
 107     {
 108       new_mem = g_malloc (byte_size);
 109       memcpy (new_mem, mem, byte_size);
 110     }
 111   else
 112     new_mem = NULL;
 113
 114   return new_mem;
 115 }
 116
 117 /**
 118  * g_strndup:
 119  * @str: the string to duplicate
 120  * @n: the maximum number of bytes to copy from @str
 121  *
 122  * Duplicates the first @n bytes of a string, returning a newly-allocated
 123  * buffer @n + 1 bytes long which will always be nul-terminated.
 124  * If @str is less than @n bytes long the buffer is padded with nuls.
 125  * If @str is %NULL it returns %NULL.
 126  * The returned value should be freed when no longer needed.
 127  *
 128  * <note><para>
 129  * To copy a number of characters from a UTF-8 encoded string, use
 130  * g_utf8_strncpy() instead.
 131  * </para></note>
 132  *
 133  * Returns: a newly-allocated buffer containing the first @n bytes
 134  *          of @str, nul-terminated
 135  */
 136 gchar*
 137 g_strndup (const gchar *str,
 138            gsize        n)
 139 {
 140   gchar *new_str;
 141
 142   if (str)
 143     {
 144       new_str = g_new (gchar, n + 1);
 145       strncpy (new_str, str, n);
 146       new_str[n] = '\0';
 147     }
 148   else
 149     new_str = NULL;
 150
 151   return new_str;
 152 }
 153
 154 /**
 155  * g_strnfill:
 156  * @length: the length of the new string
 157  * @fill_char: the byte to fill the string with
 158  *
 159  * Creates a new string @length bytes long filled with @fill_char.
 160  * The returned string should be freed when no longer needed.
 161  *
 162  * Returns: a newly-allocated string filled the @fill_char
 163  */
 164 gchar*
 165 g_strnfill (gsize length,
 166             gchar fill_char)
 167 {
 168   gchar *str;
 169
 170   str = g_new (gchar, length + 1);
 171   memset (str, (guchar)fill_char, length);
 172   str[length] = '\0';
 173
 174   return str;
 175 }
 176
 177 /**
 178  * g_stpcpy:
 179  * @dest: destination buffer.
 180  * @src: source string.
 181  *
 182  * Copies a nul-terminated string into the dest buffer, include the
 183  * trailing nul, and return a pointer to the trailing nul byte.
 184  * This is useful for concatenating multiple strings together
 185  * without having to repeatedly scan for the end.
 186  *
 187  * Return value: a pointer to trailing nul byte.
 188  **/
 189 gchar *
 190 g_stpcpy (gchar       *dest,
 191           const gchar *src)
 192 {
 193 #ifdef HAVE_STPCPY
 194   g_return_val_if_fail (dest != NULL, NULL);
 195   g_return_val_if_fail (src != NULL, NULL);
 196   return stpcpy (dest, src);
 197 #else
 198   register gchar *d = dest;
 199   register const gchar *s = src;
 200
 201   g_return_val_if_fail (dest != NULL, NULL);
 202   g_return_val_if_fail (src != NULL, NULL);
 203   do
 204     *d++ = *s;
 205   while (*s++ != '\0');
 206
 207   return d - 1;
 208 #endif
 209 }
 210
 211 gchar*
 212 g_strdup_vprintf (const gchar *format,
 213                   va_list      args)
 214 {
 215   gchar *string = NULL;
 216
 217   g_vasprintf (&string, format, args);
 218
 219   return string;
 220 }
 221
 222 gchar*
 223 g_strdup_printf (const gchar *format,
 224                  ...)
 225 {
 226   gchar *buffer;
 227   va_list args;
 228
 229   va_start (args, format);
 230   buffer = g_strdup_vprintf (format, args);
 231   va_end (args);
 232
 233   return buffer;
 234 }
 235
 236 gchar*
 237 g_strconcat (const gchar *string1, ...)
 238 {
 239   gsize   l;
 240   va_list args;
 241   gchar   *s;
 242   gchar   *concat;
 243   gchar   *ptr;
 244
 245   if (!string1)
 246     return NULL;
 247
 248   l = 1 + strlen (string1);
 249   va_start (args, string1);
 250   s = va_arg (args, gchar*);
 251   while (s)
 252     {
 253       l += strlen (s);
 254       s = va_arg (args, gchar*);
 255     }
 256   va_end (args);
 257
 258   concat = g_new (gchar, l);
 259   ptr = concat;
 260
 261   ptr = g_stpcpy (ptr, string1);
 262   va_start (args, string1);
 263   s = va_arg (args, gchar*);
 264   while (s)
 265     {
 266       ptr = g_stpcpy (ptr, s);
 267       s = va_arg (args, gchar*);
 268     }
 269   va_end (args);
 270
 271   return concat;
 272 }
 273
 274 /**
 275  * g_strtod:
 276  * @nptr:    the string to convert to a numeric value.
 277  * @endptr:  if non-%NULL, it returns the character after
 278  *           the last character used in the conversion.
 279  *
 280  * Converts a string to a #gdouble value.
 281  * It calls the standard strtod() function to handle the conversion, but
 282  * if the string is not completely converted it attempts the conversion
 283  * again with g_ascii_strtod(), and returns the best match.
 284  *
 285  * This function should seldomly be used. The normal situation when reading
 286  * numbers not for human consumption is to use g_ascii_strtod(). Only when
 287  * you know that you must expect both locale formatted and C formatted numbers
 288  * should you use this. Make sure that you don't pass strings such as comma
 289  * separated lists of values, since the commas may be interpreted as a decimal
 290  * point in some locales, causing unexpected results.
 291  *
 292  * Return value: the #gdouble value.
 293  **/
 294 gdouble
 295 g_strtod (const gchar *nptr,
 296           gchar      **endptr)
 297 {
 298   gchar *fail_pos_1;
 299   gchar *fail_pos_2;
 300   gdouble val_1;
 301   gdouble val_2 = 0;
 302
 303   g_return_val_if_fail (nptr != NULL, 0);
 304
 305   fail_pos_1 = NULL;
 306   fail_pos_2 = NULL;
 307
 308   val_1 = strtod (nptr, &fail_pos_1);
 309
 310   if (fail_pos_1 && fail_pos_1[0] != 0)
 311     val_2 = g_ascii_strtod (nptr, &fail_pos_2);
 312
 313   if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)
 314     {
 315       if (endptr)
 316         *endptr = fail_pos_1;
 317       return val_1;
 318     }
 319   else
 320     {
 321       if (endptr)
 322         *endptr = fail_pos_2;
 323       return val_2;
 324     }
 325 }
 326
 327 /**
 328  * g_ascii_strtod:
 329  * @nptr:    the string to convert to a numeric value.
 330  * @endptr:  if non-%NULL, it returns the character after
 331  *           the last character used in the conversion.
 332  *
 333  * Converts a string to a #gdouble value.
 334  * This function behaves like the standard strtod() function
 335  * does in the C locale. It does this without actually
 336  * changing the current locale, since that would not be
 337  * thread-safe.
 338  *
 339  * This function is typically used when reading configuration
 340  * files or other non-user input that should be locale independent.
 341  * To handle input from the user you should normally use the
 342  * locale-sensitive system strtod() function.
 343  *
 344  * To convert from a #gdouble to a string in a locale-insensitive
 345  * way, use g_ascii_dtostr().
 346  *
 347  * If the correct value would cause overflow, plus or minus %HUGE_VAL
 348  * is returned (according to the sign of the value), and %ERANGE is
 349  * stored in %errno. If the correct value would cause underflow,
 350  * zero is returned and %ERANGE is stored in %errno.
 351  *
 352  * This function resets %errno before calling strtod() so that
 353  * you can reliably detect overflow and underflow.
 354  *
 355  * Return value: the #gdouble value.
 356  **/
 357 gdouble
 358 g_ascii_strtod (const gchar *nptr,
 359                 gchar      **endptr)
 360 {
 361   gchar *fail_pos;
 362   gdouble val;
 363   struct lconv *locale_data;
 364   const char *decimal_point;
 365   int decimal_point_len;
 366   const char *p, *decimal_point_pos;
 367   const char *end = NULL; /* Silence gcc */
 368   int strtod_errno;
 369
 370   g_return_val_if_fail (nptr != NULL, 0);
 371
 372   fail_pos = NULL;
 373
 374   locale_data = localeconv ();
 375   decimal_point = locale_data->decimal_point;
 376   decimal_point_len = strlen (decimal_point);
 377
 378   g_assert (decimal_point_len != 0);
 379
 380   decimal_point_pos = NULL;
 381   end = NULL;
 382
 383   if (decimal_point[0] != '.' ||
 384       decimal_point[1] != 0)
 385     {
 386       p = nptr;
 387       /* Skip leading space */
 388       while (g_ascii_isspace (*p))
 389         p++;
 390
 391       /* Skip leading optional sign */
 392       if (*p == '+' || *p == '-')
 393         p++;
 394
 395       if (p[0] == '0' &&
 396           (p[1] == 'x' || p[1] == 'X'))
 397         {
 398           p += 2;
 399           /* HEX - find the (optional) decimal point */
 400
 401           while (g_ascii_isxdigit (*p))
 402             p++;
 403
 404           if (*p == '.')
 405             decimal_point_pos = p++;
 406
 407           while (g_ascii_isxdigit (*p))
 408             p++;
 409
 410           if (*p == 'p' || *p == 'P')
 411             p++;
 412           if (*p == '+' || *p == '-')
 413             p++;
 414           while (g_ascii_isdigit (*p))
 415             p++;
 416
 417           end = p;
 418         }
 419       else if (g_ascii_isdigit (*p) || *p == '.')
 420         {
 421           while (g_ascii_isdigit (*p))
 422             p++;
 423
 424           if (*p == '.')
 425             decimal_point_pos = p++;
 426
 427           while (g_ascii_isdigit (*p))
 428             p++;
 429
 430           if (*p == 'e' || *p == 'E')
 431             p++;
 432           if (*p == '+' || *p == '-')
 433             p++;
 434           while (g_ascii_isdigit (*p))
 435             p++;
 436
 437           end = p;
 438         }
 439       /* For the other cases, we need not convert the decimal point */
 440     }
 441
 442   if (decimal_point_pos)
 443     {
 444       char *copy, *c;
 445
 446       /* We need to convert the '.' to the locale specific decimal point */
 447       copy = g_malloc (end - nptr + 1 + decimal_point_len);
 448
 449       c = copy;
 450       memcpy (c, nptr, decimal_point_pos - nptr);
 451       c += decimal_point_pos - nptr;
 452       memcpy (c, decimal_point, decimal_point_len);
 453       c += decimal_point_len;
 454       memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1));
 455       c += end - (decimal_point_pos + 1);
 456       *c = 0;
 457
 458       errno = 0;
 459       val = strtod (copy, &fail_pos);
 460       strtod_errno = errno;
 461
 462       if (fail_pos)
 463         {
 464           if (fail_pos - copy > decimal_point_pos - nptr)
 465             fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);
 466           else
 467             fail_pos = (char *)nptr + (fail_pos - copy);
 468         }
 469
 470       g_free (copy);
 471
 472     }
 473   else if (end)
 474     {
 475       char *copy;
 476
 477       copy = g_malloc (end - (char *)nptr + 1);
 478       memcpy (copy, nptr, end - nptr);
 479       *(copy + (end - (char *)nptr)) = 0;
 480
 481       errno = 0;
 482       val = strtod (copy, &fail_pos);
 483       strtod_errno = errno;
 484
 485       if (fail_pos)
 486         {
 487           fail_pos = (char *)nptr + (fail_pos - copy);
 488         }
 489
 490       g_free (copy);
 491     }
 492   else
 493     {
 494       errno = 0;
 495       val = strtod (nptr, &fail_pos);
 496       strtod_errno = errno;
 497     }
 498
 499   if (endptr)
 500     *endptr = fail_pos;
 501
 502   errno = strtod_errno;
 503
 504   return val;
 505 }
 506
 507
 508 /**
 509  * g_ascii_dtostr:
 510  * @buffer: A buffer to place the resulting string in
 511  * @buf_len: The length of the buffer.
 512  * @d: The #gdouble to convert
 513  *
 514  * Converts a #gdouble to a string, using the '.' as
 515  * decimal point.
 516  *
 517  * This functions generates enough precision that converting
 518  * the string back using g_ascii_strtod() gives the same machine-number
 519  * (on machines with IEEE compatible 64bit doubles). It is
 520  * guaranteed that the size of the resulting string will never
 521  * be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes.
 522  *
 523  * Return value: The pointer to the buffer with the converted string.
 524  **/
 525 gchar *
 526 g_ascii_dtostr (gchar       *buffer,
 527                 gint         buf_len,
 528                 gdouble      d)
 529 {
 530   return g_ascii_formatd (buffer, buf_len, "%.17g", d);
 531 }
 532
 533 /**
 534  * g_ascii_formatd:
 535  * @buffer: A buffer to place the resulting string in
 536  * @buf_len: The length of the buffer.
 537  * @format: The printf()-style format to use for the
 538  *          code to use for converting.
 539  * @d: The #gdouble to convert
 540  *
 541  * Converts a #gdouble to a string, using the '.' as
 542  * decimal point. To format the number you pass in
 543  * a printf()-style format string. Allowed conversion
 544  * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
 545  *
 546  * If you just want to want to serialize the value into a
 547  * string, use g_ascii_dtostr().
 548  *
 549  * Return value: The pointer to the buffer with the converted string.
 550  **/
 551 gchar *
 552 g_ascii_formatd (gchar       *buffer,
 553                  gint         buf_len,
 554                  const gchar *format,
 555                  gdouble      d)
 556 {
 557   struct lconv *locale_data;
 558   const char *decimal_point;
 559   int decimal_point_len;
 560   gchar *p;
 561   int rest_len;
 562   gchar format_char;
 563
 564   g_return_val_if_fail (buffer != NULL, NULL);
 565   g_return_val_if_fail (format[0] == '%', NULL);
 566   g_return_val_if_fail (strpbrk (format + 1, "'l%") == NULL, NULL);
 567
 568   format_char = format[strlen (format) - 1];
 569
 570   g_return_val_if_fail (format_char == 'e' || format_char == 'E' ||
 571                         format_char == 'f' || format_char == 'F' ||
 572                         format_char == 'g' || format_char == 'G',
 573                         NULL);
 574
 575   if (format[0] != '%')
 576     return NULL;
 577
 578   if (strpbrk (format + 1, "'l%"))
 579     return NULL;
 580
 581   if (!(format_char == 'e' || format_char == 'E' ||
 582         format_char == 'f' || format_char == 'F' ||
 583         format_char == 'g' || format_char == 'G'))
 584     return NULL;
 585
 586
 587   _g_snprintf (buffer, buf_len, format, d);
 588
 589   locale_data = localeconv ();
 590   decimal_point = locale_data->decimal_point;
 591   decimal_point_len = strlen (decimal_point);
 592
 593   g_assert (decimal_point_len != 0);
 594
 595   if (decimal_point[0] != '.' ||
 596       decimal_point[1] != 0)
 597     {
 598       p = buffer;
 599
 600       while (g_ascii_isspace (*p))
 601         p++;
 602
 603       if (*p == '+' || *p == '-')
 604         p++;
 605
 606       while (isdigit ((guchar)*p))
 607         p++;
 608
 609       if (strncmp (p, decimal_point, decimal_point_len) == 0)
 610         {
 611           *p = '.';
 612           p++;
 613           if (decimal_point_len > 1) {
 614             rest_len = strlen (p + (decimal_point_len-1));
 615             memmove (p, p + (decimal_point_len-1),
 616                      rest_len);
 617             p[rest_len] = 0;
 618
 619           }
 620         }
 621     }
 622
 623   return buffer;
 624 }
 625
 626 static guint64
 627 g_parse_long_long (const gchar *nptr,
 628                    gchar      **endptr,
 629                    guint        base,
 630                    gboolean    *negative)
 631 {
 632   /* this code is based on on the strtol(3) code from GNU libc released under
 633    * the GNU Lesser General Public License.
 634    *
 635    * Copyright (C) 1991,92,94,95,96,97,98,99,2000,01,02
 636    *        Free Software Foundation, Inc.
 637    */
 638 #define ISSPACE(c)              ((c) == ' ' || (c) == '\f' || (c) == '\n' || \
 639                                  (c) == '\r' || (c) == '\t' || (c) == '\v')
 640 #define ISUPPER(c)              ((c) >= 'A' && (c) <= 'Z')
 641 #define ISLOWER(c)              ((c) >= 'a' && (c) <= 'z')
 642 #define ISALPHA(c)              (ISUPPER (c) || ISLOWER (c))
 643 #define TOUPPER(c)              (ISLOWER (c) ? (c) - 'a' + 'A' : (c))
 644 #define TOLOWER(c)              (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
 645   gboolean overflow;
 646   guint64 cutoff;
 647   guint64 cutlim;
 648   guint64 ui64;
 649   const gchar *s, *save;
 650   guchar c;
 651
 652   g_return_val_if_fail (nptr != NULL, 0);
 653
 654   if (base == 1 || base > 36)
 655     {
 656       errno = EINVAL;
 657       return 0;
 658     }
 659
 660   save = s = nptr;
 661
 662   /* Skip white space.  */
 663   while (ISSPACE (*s))
 664     ++s;
 665
 666   if (G_UNLIKELY (!*s))
 667     goto noconv;
 668
 669   /* Check for a sign.  */
 670   *negative = FALSE;
 671   if (*s == '-')
 672     {
 673       *negative = TRUE;
 674       ++s;
 675     }
 676   else if (*s == '+')
 677     ++s;
 678
 679   /* Recognize number prefix and if BASE is zero, figure it out ourselves.  */
 680   if (*s == '0')
 681     {
 682       if ((base == 0 || base == 16) && TOUPPER (s[1]) == 'X')
 683         {
 684           s += 2;
 685           base = 16;
 686         }
 687       else if (base == 0)
 688         base = 8;
 689     }
 690   else if (base == 0)
 691     base = 10;
 692
 693   /* Save the pointer so we can check later if anything happened.  */
 694   save = s;
 695   cutoff = G_MAXUINT64 / base;
 696   cutlim = G_MAXUINT64 % base;
 697
 698   overflow = FALSE;
 699   ui64 = 0;
 700   c = *s;
 701   for (; c; c = *++s)
 702     {
 703       if (c >= '0' && c <= '9')
 704         c -= '0';
 705       else if (ISALPHA (c))
 706         c = TOUPPER (c) - 'A' + 10;
 707       else
 708         break;
 709       if (c >= base)
 710         break;
 711       /* Check for overflow.  */
 712       if (ui64 > cutoff || (ui64 == cutoff && c > cutlim))
 713         overflow = TRUE;
 714       else
 715         {
 716           ui64 *= base;
 717           ui64 += c;
 718         }
 719     }
 720
 721   /* Check if anything actually happened.  */
 722   if (s == save)
 723     goto noconv;
 724
 725   /* Store in ENDPTR the address of one character
 726      past the last character we converted.  */
 727   if (endptr)
 728     *endptr = (gchar*) s;
 729
 730   if (G_UNLIKELY (overflow))
 731     {
 732       errno = ERANGE;
 733       return G_MAXUINT64;
 734     }
 735
 736   return ui64;
 737
 738  noconv:
 739   /* We must handle a special case here: the base is 0 or 16 and the
 740      first two characters are '0' and 'x', but the rest are no
 741      hexadecimal digits.  This is no error case.  We return 0 and
 742      ENDPTR points to the `x`.  */
 743   if (endptr)
 744     {
 745       if (save - nptr >= 2 && TOUPPER (save[-1]) == 'X'
 746           && save[-2] == '0')
 747         *endptr = (gchar*) &save[-1];
 748       else
 749         /*  There was no number to convert.  */
 750         *endptr = (gchar*) nptr;
 751     }
 752   return 0;
 753 }
 754
 755 /**
 756  * g_ascii_strtoull:
 757  * @nptr:    the string to convert to a numeric value.
 758  * @endptr:  if non-%NULL, it returns the character after
 759  *           the last character used in the conversion.
 760  * @base:    to be used for the conversion, 2..36 or 0
 761  *
 762  * Converts a string to a #guint64 value.
 763  * This function behaves like the standard strtoull() function
 764  * does in the C locale. It does this without actually
 765  * changing the current locale, since that would not be
 766  * thread-safe.
 767  *
 768  * This function is typically used when reading configuration
 769  * files or other non-user input that should be locale independent.
 770  * To handle input from the user you should normally use the
 771  * locale-sensitive system strtoull() function.
 772  *
 773  * If the correct value would cause overflow, %G_MAXUINT64
 774  * is returned, and %ERANGE is stored in %errno.  If the base is
 775  * outside the valid range, zero is returned, and %EINVAL is stored
 776  * in %errno.  If the string conversion fails, zero is returned, and
 777  * @endptr returns @nptr (if @endptr is non-%NULL).
 778  *
 779  * Return value: the #guint64 value or zero on error.
 780  *
 781  * Since: 2.2
 782  **/
 783 guint64
 784 g_ascii_strtoull (const gchar *nptr,
 785                   gchar      **endptr,
 786                   guint        base)
 787 {
 788   gboolean negative;
 789   guint64 result;
 790
 791   result = g_parse_long_long (nptr, endptr, base, &negative);
 792
 793   /* Return the result of the appropriate sign.  */
 794   return negative ? -result : result;
 795 }
 796
 797 /**
 798  * g_ascii_strtoll:
 799  * @nptr:    the string to convert to a numeric value.
 800  * @endptr:  if non-%NULL, it returns the character after
 801  *           the last character used in the conversion.
 802  * @base:    to be used for the conversion, 2..36 or 0
 803  *
 804  * Converts a string to a #gint64 value.
 805  * This function behaves like the standard strtoll() function
 806  * does in the C locale. It does this without actually
 807  * changing the current locale, since that would not be
 808  * thread-safe.
 809  *
 810  * This function is typically used when reading configuration
 811  * files or other non-user input that should be locale independent.
 812  * To handle input from the user you should normally use the
 813  * locale-sensitive system strtoll() function.
 814  *
 815  * If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64
 816  * is returned, and %ERANGE is stored in %errno.  If the base is
 817  * outside the valid range, zero is returned, and %EINVAL is stored
 818  * in %errno.  If the string conversion fails, zero is returned, and
 819  * @endptr returns @nptr (if @endptr is non-%NULL).
 820  *
 821  * Return value: the #gint64 value or zero on error.
 822  *
 823  * Since: 2.12
 824  **/
 825 gint64
 826 g_ascii_strtoll (const gchar *nptr,
 827                  gchar      **endptr,
 828                  guint        base)
 829 {
 830   gboolean negative;
 831   guint64 result;
 832
 833   result = g_parse_long_long (nptr, endptr, base, &negative);
 834
 835   if (negative && result > (guint64) G_MININT64)
 836     {
 837       errno = ERANGE;
 838       return G_MININT64;
 839     }
 840   else if (!negative && result > (guint64) G_MAXINT64)
 841     {
 842       errno = ERANGE;
 843       return G_MAXINT64;
 844     }
 845   else if (negative)
 846     return - (gint64) result;
 847   else
 848     return (gint64) result;
 849 }
 850
 851 G_CONST_RETURN gchar*
 852 g_strerror (gint errnum)
 853 {
 854   static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
 855   char *msg;
 856   int saved_errno = errno;
 857
 858 #ifdef HAVE_STRERROR
 859   const char *msg_locale;
 860
 861   msg_locale = strerror (errnum);
 862   if (g_get_charset (NULL))
 863     {
 864       errno = saved_errno;
 865       return msg_locale;
 866     }
 867   else
 868     {
 869       gchar *msg_utf8 = g_locale_to_utf8 (msg_locale, -1, NULL, NULL, NULL);
 870       if (msg_utf8)
 871         {
 872           /* Stick in the quark table so that we can return a static result
 873            */
 874           GQuark msg_quark = g_quark_from_string (msg_utf8);
 875           g_free (msg_utf8);
 876
 877           msg_utf8 = (gchar *) g_quark_to_string (msg_quark);
 878           errno = saved_errno;
 879           return msg_utf8;
 880         }
 881     }
 882 #elif NO_SYS_ERRLIST
 883   switch (errnum)
 884     {
 885 #ifdef E2BIG
 886     case E2BIG: return "argument list too long";
 887 #endif
 888 #ifdef EACCES
 889     case EACCES: return "permission denied";
 890 #endif
 891 #ifdef EADDRINUSE
 892     case EADDRINUSE: return "address already in use";
 893 #endif
 894 #ifdef EADDRNOTAVAIL
 895     case EADDRNOTAVAIL: return "can't assign requested address";
 896 #endif
 897 #ifdef EADV
 898     case EADV: return "advertise error";
 899 #endif
 900 #ifdef EAFNOSUPPORT
 901     case EAFNOSUPPORT: return "address family not supported by protocol family";
 902 #endif
 903 #ifdef EAGAIN
 904     case EAGAIN: return "try again";
 905 #endif
 906 #ifdef EALIGN
 907     case EALIGN: return "EALIGN";
 908 #endif
 909 #ifdef EALREADY
 910     case EALREADY: return "operation already in progress";
 911 #endif
 912 #ifdef EBADE
 913     case EBADE: return "bad exchange descriptor";
 914 #endif
 915 #ifdef EBADF
 916     case EBADF: return "bad file number";
 917 #endif
 918 #ifdef EBADFD
 919     case EBADFD: return "file descriptor in bad state";
 920 #endif
 921 #ifdef EBADMSG
 922     case EBADMSG: return "not a data message";
 923 #endif
 924 #ifdef EBADR
 925     case EBADR: return "bad request descriptor";
 926 #endif
 927 #ifdef EBADRPC
 928     case EBADRPC: return "RPC structure is bad";
 929 #endif
 930 #ifdef EBADRQC
 931     case EBADRQC: return "bad request code";
 932 #endif
 933 #ifdef EBADSLT
 934     case EBADSLT: return "invalid slot";
 935 #endif
 936 #ifdef EBFONT
 937     case EBFONT: return "bad font file format";
 938 #endif
 939 #ifdef EBUSY
 940     case EBUSY: return "mount device busy";
 941 #endif
 942 #ifdef ECHILD
 943     case ECHILD: return "no children";
 944 #endif
 945 #ifdef ECHRNG
 946     case ECHRNG: return "channel number out of range";
 947 #endif
 948 #ifdef ECOMM
 949     case ECOMM: return "communication error on send";
 950 #endif
 951 #ifdef ECONNABORTED
 952     case ECONNABORTED: return "software caused connection abort";
 953 #endif
 954 #ifdef ECONNREFUSED
 955     case ECONNREFUSED: return "connection refused";
 956 #endif
 957 #ifdef ECONNRESET
 958     case ECONNRESET: return "connection reset by peer";
 959 #endif
 960 #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))
 961     case EDEADLK: return "resource deadlock avoided";
 962 #endif
 963 #ifdef EDEADLOCK
 964     case EDEADLOCK: return "resource deadlock avoided";
 965 #endif
 966 #ifdef EDESTADDRREQ
 967     case EDESTADDRREQ: return "destination address required";
 968 #endif
 969 #ifdef EDIRTY
 970     case EDIRTY: return "mounting a dirty fs w/o force";
 971 #endif
 972 #ifdef EDOM
 973     case EDOM: return "math argument out of range";
 974 #endif
 975 #ifdef EDOTDOT
 976     case EDOTDOT: return "cross mount point";
 977 #endif
 978 #ifdef EDQUOT
 979     case EDQUOT: return "disk quota exceeded";
 980 #endif
 981 #ifdef EDUPPKG
 982     case EDUPPKG: return "duplicate package name";
 983 #endif
 984 #ifdef EEXIST
 985     case EEXIST: return "file already exists";
 986 #endif
 987 #ifdef EFAULT
 988     case EFAULT: return "bad address in system call argument";
 989 #endif
 990 #ifdef EFBIG
 991     case EFBIG: return "file too large";
 992 #endif
 993 #ifdef EHOSTDOWN
 994     case EHOSTDOWN: return "host is down";
 995 #endif
 996 #ifdef EHOSTUNREACH
 997     case EHOSTUNREACH: return "host is unreachable";
 998 #endif
 999 #ifdef EIDRM
1000     case EIDRM: return "identifier removed";
1001 #endif
1002 #ifdef EINIT
1003     case EINIT: return "initialization error";
1004 #endif
1005 #ifdef EINPROGRESS
1006     case EINPROGRESS: return "operation now in progress";
1007 #endif
1008 #ifdef EINTR
1009     case EINTR: return "interrupted system call";
1010 #endif
1011 #ifdef EINVAL
1012     case EINVAL: return "invalid argument";
1013 #endif
1014 #ifdef EIO
1015     case EIO: return "I/O error";
1016 #endif
1017 #ifdef EISCONN
1018     case EISCONN: return "socket is already connected";
1019 #endif
1020 #ifdef EISDIR
1021     case EISDIR: return "is a directory";
1022 #endif
1023 #ifdef EISNAME
1024     case EISNAM: return "is a name file";
1025 #endif
1026 #ifdef ELBIN
1027     case ELBIN: return "ELBIN";
1028 #endif
1029 #ifdef EL2HLT
1030     case EL2HLT: return "level 2 halted";
1031 #endif
1032 #ifdef EL2NSYNC
1033     case EL2NSYNC: return "level 2 not synchronized";
1034 #endif
1035 #ifdef EL3HLT
1036     case EL3HLT: return "level 3 halted";
1037 #endif
1038 #ifdef EL3RST
1039     case EL3RST: return "level 3 reset";
1040 #endif
1041 #ifdef ELIBACC
1042     case ELIBACC: return "can not access a needed shared library";
1043 #endif
1044 #ifdef ELIBBAD
1045     case ELIBBAD: return "accessing a corrupted shared library";
1046 #endif
1047 #ifdef ELIBEXEC
1048     case ELIBEXEC: return "can not exec a shared library directly";
1049 #endif
1050 #ifdef ELIBMAX
1051     case ELIBMAX: return "attempting to link in more shared libraries than system limit";
1052 #endif
1053 #ifdef ELIBSCN
1054     case ELIBSCN: return ".lib section in a.out corrupted";
1055 #endif
1056 #ifdef ELNRNG
1057     case ELNRNG: return "link number out of range";
1058 #endif
1059 #ifdef ELOOP
1060     case ELOOP: return "too many levels of symbolic links";
1061 #endif
1062 #ifdef EMFILE
1063     case EMFILE: return "too many open files";
1064 #endif
1065 #ifdef EMLINK
1066     case EMLINK: return "too many links";
1067 #endif
1068 #ifdef EMSGSIZE
1069     case EMSGSIZE: return "message too long";
1070 #endif
1071 #ifdef EMULTIHOP
1072     case EMULTIHOP: return "multihop attempted";
1073 #endif
1074 #ifdef ENAMETOOLONG
1075     case ENAMETOOLONG: return "file name too long";
1076 #endif
1077 #ifdef ENAVAIL
1078     case ENAVAIL: return "not available";
1079 #endif
1080 #ifdef ENET
1081     case ENET: return "ENET";
1082 #endif
1083 #ifdef ENETDOWN
1084     case ENETDOWN: return "network is down";
1085 #endif
1086 #ifdef ENETRESET
1087     case ENETRESET: return "network dropped connection on reset";
1088 #endif
1089 #ifdef ENETUNREACH
1090     case ENETUNREACH: return "network is unreachable";
1091 #endif
1092 #ifdef ENFILE
1093     case ENFILE: return "file table overflow";
1094 #endif
1095 #ifdef ENOANO
1096     case ENOANO: return "anode table overflow";
1097 #endif
1098 #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))
1099     case ENOBUFS: return "no buffer space available";
1100 #endif
1101 #ifdef ENOCSI
1102     case ENOCSI: return "no CSI structure available";
1103 #endif
1104 #ifdef ENODATA
1105     case ENODATA: return "no data available";
1106 #endif
1107 #ifdef ENODEV
1108     case ENODEV: return "no such device";
1109 #endif
1110 #ifdef ENOENT
1111     case ENOENT: return "no such file or directory";
1112 #endif
1113 #ifdef ENOEXEC
1114     case ENOEXEC: return "exec format error";
1115 #endif
1116 #ifdef ENOLCK
1117     case ENOLCK: return "no locks available";
1118 #endif
1119 #ifdef ENOLINK
1120     case ENOLINK: return "link has be severed";
1121 #endif
1122 #ifdef ENOMEM
1123     case ENOMEM: return "not enough memory";
1124 #endif
1125 #ifdef ENOMSG
1126     case ENOMSG: return "no message of desired type";
1127 #endif
1128 #ifdef ENONET
1129     case ENONET: return "machine is not on the network";
1130 #endif
1131 #ifdef ENOPKG
1132     case ENOPKG: return "package not installed";
1133 #endif
1134 #ifdef ENOPROTOOPT
1135     case ENOPROTOOPT: return "bad proocol option";
1136 #endif
1137 #ifdef ENOSPC
1138     case ENOSPC: return "no space left on device";
1139 #endif
1140 #ifdef ENOSR
1141     case ENOSR: return "out of stream resources";
1142 #endif
1143 #ifdef ENOSTR
1144     case ENOSTR: return "not a stream device";
1145 #endif
1146 #ifdef ENOSYM
1147     case ENOSYM: return "unresolved symbol name";
1148 #endif
1149 #ifdef ENOSYS
1150     case ENOSYS: return "function not implemented";
1151 #endif
1152 #ifdef ENOTBLK
1153     case ENOTBLK: return "block device required";
1154 #endif
1155 #ifdef ENOTCONN
1156     case ENOTCONN: return "socket is not connected";
1157 #endif
1158 #ifdef ENOTDIR
1159     case ENOTDIR: return "not a directory";
1160 #endif
1161 #ifdef ENOTEMPTY
1162     case ENOTEMPTY: return "directory not empty";
1163 #endif
1164 #ifdef ENOTNAM
1165     case ENOTNAM: return "not a name file";
1166 #endif
1167 #ifdef ENOTSOCK
1168     case ENOTSOCK: return "socket operation on non-socket";
1169 #endif
1170 #ifdef ENOTTY
1171     case ENOTTY: return "inappropriate device for ioctl";
1172 #endif
1173 #ifdef ENOTUNIQ
1174     case ENOTUNIQ: return "name not unique on network";
1175 #endif
1176 #ifdef ENXIO
1177     case ENXIO: return "no such device or address";
1178 #endif
1179 #ifdef EOPNOTSUPP
1180     case EOPNOTSUPP: return "operation not supported on socket";
1181 #endif
1182 #ifdef EPERM
1183     case EPERM: return "not owner";
1184 #endif
1185 #ifdef EPFNOSUPPORT
1186     case EPFNOSUPPORT: return "protocol family not supported";
1187 #endif
1188 #ifdef EPIPE
1189     case EPIPE: return "broken pipe";
1190 #endif
1191 #ifdef EPROCLIM
1192     case EPROCLIM: return "too many processes";
1193 #endif
1194 #ifdef EPROCUNAVAIL
1195     case EPROCUNAVAIL: return "bad procedure for program";
1196 #endif
1197 #ifdef EPROGMISMATCH
1198     case EPROGMISMATCH: return "program version wrong";
1199 #endif
1200 #ifdef EPROGUNAVAIL
1201     case EPROGUNAVAIL: return "RPC program not available";
1202 #endif
1203 #ifdef EPROTO
1204     case EPROTO: return "protocol error";
1205 #endif
1206 #ifdef EPROTONOSUPPORT
1207     case EPROTONOSUPPORT: return "protocol not suppored";
1208 #endif
1209 #ifdef EPROTOTYPE
1210     case EPROTOTYPE: return "protocol wrong type for socket";
1211 #endif
1212 #ifdef ERANGE
1213     case ERANGE: return "math result unrepresentable";
1214 #endif
1215 #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))
1216     case EREFUSED: return "EREFUSED";
1217 #endif
1218 #ifdef EREMCHG
1219     case EREMCHG: return "remote address changed";
1220 #endif
1221 #ifdef EREMDEV
1222     case EREMDEV: return "remote device";
1223 #endif
1224 #ifdef EREMOTE
1225     case EREMOTE: return "pathname hit remote file system";
1226 #endif
1227 #ifdef EREMOTEIO
1228     case EREMOTEIO: return "remote i/o error";
1229 #endif
1230 #ifdef EREMOTERELEASE
1231     case EREMOTERELEASE: return "EREMOTERELEASE";
1232 #endif
1233 #ifdef EROFS
1234     case EROFS: return "read-only file system";
1235 #endif
1236 #ifdef ERPCMISMATCH
1237     case ERPCMISMATCH: return "RPC version is wrong";
1238 #endif
1239 #ifdef ERREMOTE
1240     case ERREMOTE: return "object is remote";
1241 #endif
1242 #ifdef ESHUTDOWN
1243     case ESHUTDOWN: return "can't send afer socket shutdown";
1244 #endif
1245 #ifdef ESOCKTNOSUPPORT
1246     case ESOCKTNOSUPPORT: return "socket type not supported";
1247 #endif
1248 #ifdef ESPIPE
1249     case ESPIPE: return "invalid seek";
1250 #endif
1251 #ifdef ESRCH
1252     case ESRCH: return "no such process";
1253 #endif
1254 #ifdef ESRMNT
1255     case ESRMNT: return "srmount error";
1256 #endif
1257 #ifdef ESTALE
1258     case ESTALE: return "stale remote file handle";
1259 #endif
1260 #ifdef ESUCCESS
1261     case ESUCCESS: return "Error 0";
1262 #endif
1263 #ifdef ETIME
1264     case ETIME: return "timer expired";
1265 #endif
1266 #ifdef ETIMEDOUT
1267     case ETIMEDOUT: return "connection timed out";
1268 #endif
1269 #ifdef ETOOMANYREFS
1270     case ETOOMANYREFS: return "too many references: can't splice";
1271 #endif
1272 #ifdef ETXTBSY
1273     case ETXTBSY: return "text file or pseudo-device busy";
1274 #endif
1275 #ifdef EUCLEAN
1276     case EUCLEAN: return "structure needs cleaning";
1277 #endif
1278 #ifdef EUNATCH
1279     case EUNATCH: return "protocol driver not attached";
1280 #endif
1281 #ifdef EUSERS
1282     case EUSERS: return "too many users";
1283 #endif
1284 #ifdef EVERSION
1285     case EVERSION: return "version mismatch";
1286 #endif
1287 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
1288     case EWOULDBLOCK: return "operation would block";
1289 #endif
1290 #ifdef EXDEV
1291     case EXDEV: return "cross-domain link";
1292 #endif
1293 #ifdef EXFULL
1294     case EXFULL: return "message tables full";
1295 #endif
1296     }
1297 #else /* NO_SYS_ERRLIST */
1298   extern int sys_nerr;
1299   extern char *sys_errlist[];
1300
1301   if ((errnum > 0) && (errnum <= sys_nerr))
1302     return sys_errlist [errnum];
1303 #endif /* NO_SYS_ERRLIST */
1304
1305   msg = g_static_private_get (&msg_private);
1306   if (!msg)
1307     {
1308       msg = g_new (gchar, 64);
1309       g_static_private_set (&msg_private, msg, g_free);
1310     }
1311
1312   _g_sprintf (msg, "unknown error (%d)", errnum);
1313
1314   errno = saved_errno;
1315   return msg;
1316 }
1317
1318 G_CONST_RETURN gchar*
1319 g_strsignal (gint signum)
1320 {
1321   static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
1322   char *msg;
1323
1324 #ifdef HAVE_STRSIGNAL
1325   const char *msg_locale;
1326
1327 #if defined(G_OS_BEOS) || defined(G_WITH_CYGWIN)
1328 extern const char *strsignal(int);
1329 #else
1330   /* this is declared differently (const) in string.h on BeOS */
1331   extern char *strsignal (int sig);
1332 #endif /* !G_OS_BEOS && !G_WITH_CYGWIN */
1333   msg_locale = strsignal (signum);
1334   if (g_get_charset (NULL))
1335     return msg_locale;
1336   else
1337     {
1338       gchar *msg_utf8 = g_locale_to_utf8 (msg_locale, -1, NULL, NULL, NULL);
1339       if (msg_utf8)
1340         {
1341           /* Stick in the quark table so that we can return a static result
1342            */
1343           GQuark msg_quark = g_quark_from_string (msg_utf8);
1344           g_free (msg_utf8);
1345
1346           return g_quark_to_string (msg_quark);
1347         }
1348     }
1349 #elif NO_SYS_SIGLIST
1350   switch (signum)
1351     {
1352 #ifdef SIGHUP
1353     case SIGHUP: return "Hangup";
1354 #endif
1355 #ifdef SIGINT
1356     case SIGINT: return "Interrupt";
1357 #endif
1358 #ifdef SIGQUIT
1359     case SIGQUIT: return "Quit";
1360 #endif
1361 #ifdef SIGILL
1362     case SIGILL: return "Illegal instruction";
1363 #endif
1364 #ifdef SIGTRAP
1365     case SIGTRAP: return "Trace/breakpoint trap";
1366 #endif
1367 #ifdef SIGABRT
1368     case SIGABRT: return "IOT trap/Abort";
1369 #endif
1370 #ifdef SIGBUS
1371     case SIGBUS: return "Bus error";
1372 #endif
1373 #ifdef SIGFPE
1374     case SIGFPE: return "Floating point exception";
1375 #endif
1376 #ifdef SIGKILL
1377     case SIGKILL: return "Killed";
1378 #endif
1379 #ifdef SIGUSR1
1380     case SIGUSR1: return "User defined signal 1";
1381 #endif
1382 #ifdef SIGSEGV
1383     case SIGSEGV: return "Segmentation fault";
1384 #endif
1385 #ifdef SIGUSR2
1386     case SIGUSR2: return "User defined signal 2";
1387 #endif
1388 #ifdef SIGPIPE
1389     case SIGPIPE: return "Broken pipe";
1390 #endif
1391 #ifdef SIGALRM
1392     case SIGALRM: return "Alarm clock";
1393 #endif
1394 #ifdef SIGTERM
1395     case SIGTERM: return "Terminated";
1396 #endif
1397 #ifdef SIGSTKFLT
1398     case SIGSTKFLT: return "Stack fault";
1399 #endif
1400 #ifdef SIGCHLD
1401     case SIGCHLD: return "Child exited";
1402 #endif
1403 #ifdef SIGCONT
1404     case SIGCONT: return "Continued";
1405 #endif
1406 #ifdef SIGSTOP
1407     case SIGSTOP: return "Stopped (signal)";
1408 #endif
1409 #ifdef SIGTSTP
1410     case SIGTSTP: return "Stopped";
1411 #endif
1412 #ifdef SIGTTIN
1413     case SIGTTIN: return "Stopped (tty input)";
1414 #endif
1415 #ifdef SIGTTOU
1416     case SIGTTOU: return "Stopped (tty output)";
1417 #endif
1418 #ifdef SIGURG
1419     case SIGURG: return "Urgent condition";
1420 #endif
1421 #ifdef SIGXCPU
1422     case SIGXCPU: return "CPU time limit exceeded";
1423 #endif
1424 #ifdef SIGXFSZ
1425     case SIGXFSZ: return "File size limit exceeded";
1426 #endif
1427 #ifdef SIGVTALRM
1428     case SIGVTALRM: return "Virtual time alarm";
1429 #endif
1430 #ifdef SIGPROF
1431     case SIGPROF: return "Profile signal";
1432 #endif
1433 #ifdef SIGWINCH
1434     case SIGWINCH: return "Window size changed";
1435 #endif
1436 #ifdef SIGIO
1437     case SIGIO: return "Possible I/O";
1438 #endif
1439 #ifdef SIGPWR
1440     case SIGPWR: return "Power failure";
1441 #endif
1442 #ifdef SIGUNUSED
1443     case SIGUNUSED: return "Unused signal";
1444 #endif
1445     }
1446 #else /* NO_SYS_SIGLIST */
1447
1448 #ifdef NO_SYS_SIGLIST_DECL
1449   extern char *sys_siglist[];   /*(see Tue Jan 19 00:44:24 1999 in changelog)*/
1450 #endif
1451
1452   return (char*) /* this function should return const --josh */ sys_siglist [signum];
1453 #endif /* NO_SYS_SIGLIST */
1454
1455   msg = g_static_private_get (&msg_private);
1456   if (!msg)
1457     {
1458       msg = g_new (gchar, 64);
1459       g_static_private_set (&msg_private, msg, g_free);
1460     }
1461
1462   _g_sprintf (msg, "unknown signal (%d)", signum);
1463
1464   return msg;
1465 }
1466
1467 /* Functions g_strlcpy and g_strlcat were originally developed by
1468  * Todd C. Miller <Todd.Miller@courtesan.com> to simplify writing secure code.
1469  * See ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3
1470  * for more information.
1471  */
1472
1473 #ifdef HAVE_STRLCPY
1474 /* Use the native ones, if available; they might be implemented in assembly */
1475 gsize
1476 g_strlcpy (gchar       *dest,
1477            const gchar *src,
1478            gsize        dest_size)
1479 {
1480   g_return_val_if_fail (dest != NULL, 0);
1481   g_return_val_if_fail (src  != NULL, 0);
1482
1483   return strlcpy (dest, src, dest_size);
1484 }
1485
1486 gsize
1487 g_strlcat (gchar       *dest,
1488            const gchar *src,
1489            gsize        dest_size)
1490 {
1491   g_return_val_if_fail (dest != NULL, 0);
1492   g_return_val_if_fail (src  != NULL, 0);
1493
1494   return strlcat (dest, src, dest_size);
1495 }
1496
1497 #else /* ! HAVE_STRLCPY */
1498 /* g_strlcpy
1499  *
1500  * Copy string src to buffer dest (of buffer size dest_size).  At most
1501  * dest_size-1 characters will be copied.  Always NUL terminates
1502  * (unless dest_size == 0).  This function does NOT allocate memory.
1503  * Unlike strncpy, this function doesn't pad dest (so it's often faster).
1504  * Returns size of attempted result, strlen(src),
1505  * so if retval >= dest_size, truncation occurred.
1506  */
1507 gsize
1508 g_strlcpy (gchar       *dest,
1509            const gchar *src,
1510            gsize        dest_size)
1511 {
1512   register gchar *d = dest;
1513   register const gchar *s = src;
1514   register gsize n = dest_size;
1515
1516   g_return_val_if_fail (dest != NULL, 0);
1517   g_return_val_if_fail (src  != NULL, 0);
1518
1519   /* Copy as many bytes as will fit */
1520   if (n != 0 && --n != 0)
1521     do
1522       {
1523         register gchar c = *s++;
1524
1525         *d++ = c;
1526         if (c == 0)
1527           break;
1528       }
1529     while (--n != 0);
1530
1531   /* If not enough room in dest, add NUL and traverse rest of src */
1532   if (n == 0)
1533     {
1534       if (dest_size != 0)
1535         *d = 0;
1536       while (*s++)
1537         ;
1538     }
1539
1540   return s - src - 1;  /* count does not include NUL */
1541 }
1542
1543 /* g_strlcat
1544  *
1545  * Appends string src to buffer dest (of buffer size dest_size).
1546  * At most dest_size-1 characters will be copied.
1547  * Unlike strncat, dest_size is the full size of dest, not the space left over.
1548  * This function does NOT allocate memory.
1549  * This always NUL terminates (unless siz == 0 or there were no NUL characters
1550  * in the dest_size characters of dest to start with).
1551  * Returns size of attempted result, which is
1552  * MIN (dest_size, strlen (original dest)) + strlen (src),
1553  * so if retval >= dest_size, truncation occurred.
1554  */
1555 gsize
1556 g_strlcat (gchar       *dest,
1557            const gchar *src,
1558            gsize        dest_size)
1559 {
1560   register gchar *d = dest;
1561   register const gchar *s = src;
1562   register gsize bytes_left = dest_size;
1563   gsize dlength;  /* Logically, MIN (strlen (d), dest_size) */
1564
1565   g_return_val_if_fail (dest != NULL, 0);
1566   g_return_val_if_fail (src  != NULL, 0);
1567
1568   /* Find the end of dst and adjust bytes left but don't go past end */
1569   while (*d != 0 && bytes_left-- != 0)
1570     d++;
1571   dlength = d - dest;
1572   bytes_left = dest_size - dlength;
1573
1574   if (bytes_left == 0)
1575     return dlength + strlen (s);
1576
1577   while (*s != 0)
1578     {
1579       if (bytes_left != 1)
1580         {
1581           *d++ = *s;
1582           bytes_left--;
1583         }
1584       s++;
1585     }
1586   *d = 0;
1587
1588   return dlength + (s - src);  /* count does not include NUL */
1589 }
1590 #endif /* ! HAVE_STRLCPY */
1591
1592 /**
1593  * g_ascii_strdown:
1594  * @str: a string.
1595  * @len: length of @str in bytes, or -1 if @str is nul-terminated.
1596  *
1597  * Converts all upper case ASCII letters to lower case ASCII letters.
1598  *
1599  * Return value: a newly-allocated string, with all the upper case
1600  *               characters in @str converted to lower case, with
1601  *               semantics that exactly match g_ascii_tolower(). (Note
1602  *               that this is unlike the old g_strdown(), which modified
1603  *               the string in place.)
1604  **/
1605 gchar*
1606 g_ascii_strdown (const gchar *str,
1607                  gssize       len)
1608 {
1609   gchar *result, *s;
1610
1611   g_return_val_if_fail (str != NULL, NULL);
1612
1613   if (len < 0)
1614     len = strlen (str);
1615
1616   result = g_strndup (str, len);
1617   for (s = result; *s; s++)
1618     *s = g_ascii_tolower (*s);
1619
1620   return result;
1621 }
1622
1623 /**
1624  * g_ascii_strup:
1625  * @str: a string.
1626  * @len: length of @str in bytes, or -1 if @str is nul-terminated.
1627  *
1628  * Converts all lower case ASCII letters to upper case ASCII letters.
1629  *
1630  * Return value: a newly allocated string, with all the lower case
1631  *               characters in @str converted to upper case, with
1632  *               semantics that exactly match g_ascii_toupper(). (Note
1633  *               that this is unlike the old g_strup(), which modified
1634  *               the string in place.)
1635  **/
1636 gchar*
1637 g_ascii_strup (const gchar *str,
1638                gssize       len)
1639 {
1640   gchar *result, *s;
1641
1642   g_return_val_if_fail (str != NULL, NULL);
1643
1644   if (len < 0)
1645     len = strlen (str);
1646
1647   result = g_strndup (str, len);
1648   for (s = result; *s; s++)
1649     *s = g_ascii_toupper (*s);
1650
1651   return result;
1652 }
1653
1654 /**
1655  * g_strdown:
1656  * @string: the string to convert.
1657  *
1658  * Converts a string to lower case.
1659  *
1660  * Return value: the string
1661  *
1662  * Deprecated:2.2: This function is totally broken for the reasons discussed
1663  * in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown()
1664  * instead.
1665  **/
1666 gchar*
1667 g_strdown (gchar *string)
1668 {
1669   register guchar *s;
1670
1671   g_return_val_if_fail (string != NULL, NULL);
1672
1673   s = (guchar *) string;
1674
1675   while (*s)
1676     {
1677       if (isupper (*s))
1678         *s = tolower (*s);
1679       s++;
1680     }
1681
1682   return (gchar *) string;
1683 }
1684
1685 /**
1686  * g_strup:
1687  * @string: the string to convert.
1688  *
1689  * Converts a string to upper case.
1690  *
1691  * Return value: the string
1692  *
1693  * Deprecated:2.2: This function is totally broken for the reasons discussed
1694  * in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.
1695  **/
1696 gchar*
1697 g_strup (gchar *string)
1698 {
1699   register guchar *s;
1700
1701   g_return_val_if_fail (string != NULL, NULL);
1702
1703   s = (guchar *) string;
1704
1705   while (*s)
1706     {
1707       if (islower (*s))
1708         *s = toupper (*s);
1709       s++;
1710     }
1711
1712   return (gchar *) string;
1713 }
1714
1715 gchar*
1716 g_strreverse (gchar *string)
1717 {
1718   g_return_val_if_fail (string != NULL, NULL);
1719
1720   if (*string)
1721     {
1722       register gchar *h, *t;
1723
1724       h = string;
1725       t = string + strlen (string) - 1;
1726
1727       while (h < t)
1728         {
1729           register gchar c;
1730
1731           c = *h;
1732           *h = *t;
1733           h++;
1734           *t = c;
1735           t--;
1736         }
1737     }
1738
1739   return string;
1740 }
1741
1742 /**
1743  * g_ascii_tolower:
1744  * @c: any character.
1745  *
1746  * Convert a character to ASCII lower case.
1747  *
1748  * Unlike the standard C library tolower() function, this only
1749  * recognizes standard ASCII letters and ignores the locale, returning
1750  * all non-ASCII characters unchanged, even if they are lower case
1751  * letters in a particular character set. Also unlike the standard
1752  * library function, this takes and returns a char, not an int, so
1753  * don't call it on %EOF but no need to worry about casting to #guchar
1754  * before passing a possibly non-ASCII character in.
1755  *
1756  * Return value: the result of converting @c to lower case.
1757  *               If @c is not an ASCII upper case letter,
1758  *               @c is returned unchanged.
1759  **/
1760 gchar
1761 g_ascii_tolower (gchar c)
1762 {
1763   return g_ascii_isupper (c) ? c - 'A' + 'a' : c;
1764 }
1765
1766 /**
1767  * g_ascii_toupper:
1768  * @c: any character.
1769  *
1770  * Convert a character to ASCII upper case.
1771  *
1772  * Unlike the standard C library toupper() function, this only
1773  * recognizes standard ASCII letters and ignores the locale, returning
1774  * all non-ASCII characters unchanged, even if they are upper case
1775  * letters in a particular character set. Also unlike the standard
1776  * library function, this takes and returns a char, not an int, so
1777  * don't call it on %EOF but no need to worry about casting to #guchar
1778  * before passing a possibly non-ASCII character in.
1779  *
1780  * Return value: the result of converting @c to upper case.
1781  *               If @c is not an ASCII lower case letter,
1782  *               @c is returned unchanged.
1783  **/
1784 gchar
1785 g_ascii_toupper (gchar c)
1786 {
1787   return g_ascii_islower (c) ? c - 'a' + 'A' : c;
1788 }
1789
1790 /**
1791  * g_ascii_digit_value:
1792  * @c: an ASCII character.
1793  *
1794  * Determines the numeric value of a character as a decimal
1795  * digit. Differs from g_unichar_digit_value() because it takes
1796  * a char, so there's no worry about sign extension if characters
1797  * are signed.
1798  *
1799  * Return value: If @c is a decimal digit (according to
1800  * g_ascii_isdigit()), its numeric value. Otherwise, -1.
1801  **/
1802 int
1803 g_ascii_digit_value (gchar c)
1804 {
1805   if (g_ascii_isdigit (c))
1806     return c - '0';
1807   return -1;
1808 }
1809
1810 /**
1811  * g_ascii_xdigit_value:
1812  * @c: an ASCII character.
1813  *
1814  * Determines the numeric value of a character as a hexidecimal
1815  * digit. Differs from g_unichar_xdigit_value() because it takes
1816  * a char, so there's no worry about sign extension if characters
1817  * are signed.
1818  *
1819  * Return value: If @c is a hex digit (according to
1820  * g_ascii_isxdigit()), its numeric value. Otherwise, -1.
1821  **/
1822 int
1823 g_ascii_xdigit_value (gchar c)
1824 {
1825   if (c >= 'A' && c <= 'F')
1826     return c - 'A' + 10;
1827   if (c >= 'a' && c <= 'f')
1828     return c - 'a' + 10;
1829   return g_ascii_digit_value (c);
1830 }
1831
1832 /**
1833  * g_ascii_strcasecmp:
1834  * @s1: string to compare with @s2.
1835  * @s2: string to compare with @s1.
1836  *
1837  * Compare two strings, ignoring the case of ASCII characters.
1838  *
1839  * Unlike the BSD strcasecmp() function, this only recognizes standard
1840  * ASCII letters and ignores the locale, treating all non-ASCII
1841  * bytes as if they are not letters.
1842  *
1843  * This function should be used only on strings that are known to be
1844  * in encodings where the bytes corresponding to ASCII letters always
1845  * represent themselves. This includes UTF-8 and the ISO-8859-*
1846  * charsets, but not for instance double-byte encodings like the
1847  * Windows Codepage 932, where the trailing bytes of double-byte
1848  * characters include all ASCII letters. If you compare two CP932
1849  * strings using this function, you will get false matches.
1850  *
1851  * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
1852  *   or a positive value if @s1 &gt; @s2.
1853  **/
1854 gint
1855 g_ascii_strcasecmp (const gchar *s1,
1856                     const gchar *s2)
1857 {
1858   gint c1, c2;
1859
1860   g_return_val_if_fail (s1 != NULL, 0);
1861   g_return_val_if_fail (s2 != NULL, 0);
1862
1863   while (*s1 && *s2)
1864     {
1865       c1 = (gint)(guchar) TOLOWER (*s1);
1866       c2 = (gint)(guchar) TOLOWER (*s2);
1867       if (c1 != c2)
1868         return (c1 - c2);
1869       s1++; s2++;
1870     }
1871
1872   return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
1873 }
1874
1875 /**
1876  * g_ascii_strncasecmp:
1877  * @s1: string to compare with @s2.
1878  * @s2: string to compare with @s1.
1879  * @n:  number of characters to compare.
1880  *
1881  * Compare @s1 and @s2, ignoring the case of ASCII characters and any
1882  * characters after the first @n in each string.
1883  *
1884  * Unlike the BSD strcasecmp() function, this only recognizes standard
1885  * ASCII letters and ignores the locale, treating all non-ASCII
1886  * characters as if they are not letters.
1887  *
1888  * The same warning as in g_ascii_strcasecmp() applies: Use this
1889  * function only on strings known to be in encodings where bytes
1890  * corresponding to ASCII letters always represent themselves.
1891  *
1892  * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
1893  *   or a positive value if @s1 &gt; @s2.
1894  **/
1895 gint
1896 g_ascii_strncasecmp (const gchar *s1,
1897                      const gchar *s2,
1898                      gsize n)
1899 {
1900   gint c1, c2;
1901
1902   g_return_val_if_fail (s1 != NULL, 0);
1903   g_return_val_if_fail (s2 != NULL, 0);
1904
1905   while (n && *s1 && *s2)
1906     {
1907       n -= 1;
1908       c1 = (gint)(guchar) TOLOWER (*s1);
1909       c2 = (gint)(guchar) TOLOWER (*s2);
1910       if (c1 != c2)
1911         return (c1 - c2);
1912       s1++; s2++;
1913     }
1914
1915   if (n)
1916     return (((gint) (guchar) *s1) - ((gint) (guchar) *s2));
1917   else
1918     return 0;
1919 }
1920
1921 /**
1922  * g_strcasecmp:
1923  * @s1: a string.
1924  * @s2: a string to compare with @s1.
1925  *
1926  * A case-insensitive string comparison, corresponding to the standard
1927  * strcasecmp() function on platforms which support it.
1928  *
1929  * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
1930  *   or a positive value if @s1 &gt; @s2.
1931  *
1932  * Deprecated:2.2: See g_strncasecmp() for a discussion of why this function
1933  *   is deprecated and how to replace it.
1934  **/
1935 gint
1936 g_strcasecmp (const gchar *s1,
1937               const gchar *s2)
1938 {
1939 #ifdef HAVE_STRCASECMP
1940   g_return_val_if_fail (s1 != NULL, 0);
1941   g_return_val_if_fail (s2 != NULL, 0);
1942
1943   return strcasecmp (s1, s2);
1944 #else
1945   gint c1, c2;
1946
1947   g_return_val_if_fail (s1 != NULL, 0);
1948   g_return_val_if_fail (s2 != NULL, 0);
1949
1950   while (*s1 && *s2)
1951     {
1952       /* According to A. Cox, some platforms have islower's that
1953        * don't work right on non-uppercase
1954        */
1955       c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
1956       c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
1957       if (c1 != c2)
1958         return (c1 - c2);
1959       s1++; s2++;
1960     }
1961
1962   return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
1963 #endif
1964 }
1965
1966 /**
1967  * g_strncasecmp:
1968  * @s1: a string.
1969  * @s2: a string to compare with @s1.
1970  * @n: the maximum number of characters to compare.
1971  *
1972  * A case-insensitive string comparison, corresponding to the standard
1973  * strncasecmp() function on platforms which support it.
1974  * It is similar to g_strcasecmp() except it only compares the first @n
1975  * characters of the strings.
1976  *
1977  * Return value: 0 if the strings match, a negative value if @s1 &lt; @s2,
1978  *   or a positive value if @s1 &gt; @s2.
1979  *
1980  * Deprecated:2.2: The problem with g_strncasecmp() is that it does the
1981  * comparison by calling toupper()/tolower(). These functions are
1982  * locale-specific and operate on single bytes. However, it is impossible
1983  * to handle things correctly from an I18N standpoint by operating on
1984  * bytes, since characters may be multibyte. Thus g_strncasecmp() is
1985  * broken if your string is guaranteed to be ASCII, since it's
1986  * locale-sensitive, and it's broken if your string is localized, since
1987  * it doesn't work on many encodings at all, including UTF-8, EUC-JP,
1988  * etc.
1989  *
1990  * There are therefore two replacement functions: g_ascii_strncasecmp(),
1991  * which only works on ASCII and is not locale-sensitive, and
1992  * g_utf8_casefold(), which is good for case-insensitive sorting of UTF-8.
1993  **/
1994 gint
1995 g_strncasecmp (const gchar *s1,
1996                const gchar *s2,
1997                guint n)
1998 {
1999 #ifdef HAVE_STRNCASECMP
2000   return strncasecmp (s1, s2, n);
2001 #else
2002   gint c1, c2;
2003
2004   g_return_val_if_fail (s1 != NULL, 0);
2005   g_return_val_if_fail (s2 != NULL, 0);
2006
2007   while (n && *s1 && *s2)
2008     {
2009       n -= 1;
2010       /* According to A. Cox, some platforms have islower's that
2011        * don't work right on non-uppercase
2012        */
2013       c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
2014       c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
2015       if (c1 != c2)
2016         return (c1 - c2);
2017       s1++; s2++;
2018     }
2019
2020   if (n)
2021     return (((gint) (guchar) *s1) - ((gint) (guchar) *s2));
2022   else
2023     return 0;
2024 #endif
2025 }
2026
2027 gchar*
2028 g_strdelimit (gchar       *string,
2029               const gchar *delimiters,
2030               gchar        new_delim)
2031 {
2032   register gchar *c;
2033
2034   g_return_val_if_fail (string != NULL, NULL);
2035
2036   if (!delimiters)
2037     delimiters = G_STR_DELIMITERS;
2038
2039   for (c = string; *c; c++)
2040     {
2041       if (strchr (delimiters, *c))
2042         *c = new_delim;
2043     }
2044
2045   return string;
2046 }
2047
2048 gchar*
2049 g_strcanon (gchar       *string,
2050             const gchar *valid_chars,
2051             gchar        substitutor)
2052 {
2053   register gchar *c;
2054
2055   g_return_val_if_fail (string != NULL, NULL);
2056   g_return_val_if_fail (valid_chars != NULL, NULL);
2057
2058   for (c = string; *c; c++)
2059     {
2060       if (!strchr (valid_chars, *c))
2061         *c = substitutor;
2062     }
2063
2064   return string;
2065 }
2066
2067 gchar*
2068 g_strcompress (const gchar *source)
2069 {
2070   const gchar *p = source, *octal;
2071   gchar *dest = g_malloc (strlen (source) + 1);
2072   gchar *q = dest;
2073
2074   while (*p)
2075     {
2076       if (*p == '\\')
2077         {
2078           p++;
2079           switch (*p)
2080             {
2081             case '\0':
2082               g_warning ("g_strcompress: trailing \\");
2083               goto out;
2084             case '0':  case '1':  case '2':  case '3':  case '4':
2085             case '5':  case '6':  case '7':
2086               *q = 0;
2087               octal = p;
2088               while ((p < octal + 3) && (*p >= '0') && (*p <= '7'))
2089                 {
2090                   *q = (*q * 8) + (*p - '0');
2091                   p++;
2092                 }
2093               q++;
2094               p--;
2095               break;
2096             case 'b':
2097               *q++ = '\b';
2098               break;
2099             case 'f':
2100               *q++ = '\f';
2101               break;
2102             case 'n':
2103               *q++ = '\n';
2104               break;
2105             case 'r':
2106               *q++ = '\r';
2107               break;
2108             case 't':
2109               *q++ = '\t';
2110               break;
2111             default:            /* Also handles \" and \\ */
2112               *q++ = *p;
2113               break;
2114             }
2115         }
2116       else
2117         *q++ = *p;
2118       p++;
2119     }
2120 out:
2121   *q = 0;
2122
2123   return dest;
2124 }
2125
2126 gchar *
2127 g_strescape (const gchar *source,
2128              const gchar *exceptions)
2129 {
2130   const guchar *p;
2131   gchar *dest;
2132   gchar *q;
2133   guchar excmap[256];
2134
2135   g_return_val_if_fail (source != NULL, NULL);
2136
2137   p = (guchar *) source;
2138   /* Each source byte needs maximally four destination chars (\777) */
2139   q = dest = g_malloc (strlen (source) * 4 + 1);
2140
2141   memset (excmap, 0, 256);
2142   if (exceptions)
2143     {
2144       guchar *e = (guchar *) exceptions;
2145
2146       while (*e)
2147         {
2148           excmap[*e] = 1;
2149           e++;
2150         }
2151     }
2152
2153   while (*p)
2154     {
2155       if (excmap[*p])
2156         *q++ = *p;
2157       else
2158         {
2159           switch (*p)
2160             {
2161             case '\b':
2162               *q++ = '\\';
2163               *q++ = 'b';
2164               break;
2165             case '\f':
2166               *q++ = '\\';
2167               *q++ = 'f';
2168               break;
2169             case '\n':
2170               *q++ = '\\';
2171               *q++ = 'n';
2172               break;
2173             case '\r':
2174               *q++ = '\\';
2175               *q++ = 'r';
2176               break;
2177             case '\t':
2178               *q++ = '\\';
2179               *q++ = 't';
2180               break;
2181             case '\\':
2182               *q++ = '\\';
2183               *q++ = '\\';
2184               break;
2185             case '"':
2186               *q++ = '\\';
2187               *q++ = '"';
2188               break;
2189             default:
2190               if ((*p < ' ') || (*p >= 0177))
2191                 {
2192                   *q++ = '\\';
2193                   *q++ = '0' + (((*p) >> 6) & 07);
2194                   *q++ = '0' + (((*p) >> 3) & 07);
2195                   *q++ = '0' + ((*p) & 07);
2196                 }
2197               else
2198                 *q++ = *p;
2199               break;
2200             }
2201         }
2202       p++;
2203     }
2204   *q = 0;
2205   return dest;
2206 }
2207
2208 gchar*
2209 g_strchug (gchar *string)
2210 {
2211   guchar *start;
2212
2213   g_return_val_if_fail (string != NULL, NULL);
2214
2215   for (start = (guchar*) string; *start && g_ascii_isspace (*start); start++)
2216     ;
2217
2218   g_memmove (string, start, strlen ((gchar *) start) + 1);
2219
2220   return string;
2221 }
2222
2223 gchar*
2224 g_strchomp (gchar *string)
2225 {
2226   gsize len;
2227
2228   g_return_val_if_fail (string != NULL, NULL);
2229
2230   len = strlen (string);
2231   while (len--)
2232     {
2233       if (g_ascii_isspace ((guchar) string[len]))
2234         string[len] = '\0';
2235       else
2236         break;
2237     }
2238
2239   return string;
2240 }
2241
2242 /**
2243  * g_strsplit:
2244  * @string: a string to split.
2245  * @delimiter: a string which specifies the places at which to split the string.
2246  *     The delimiter is not included in any of the resulting strings, unless
2247  *     @max_tokens is reached.
2248  * @max_tokens: the maximum number of pieces to split @string into. If this is
2249  *              less than 1, the string is split completely.
2250  *
2251  * Splits a string into a maximum of @max_tokens pieces, using the given
2252  * @delimiter. If @max_tokens is reached, the remainder of @string is appended
2253  * to the last token.
2254  *
2255  * As a special case, the result of splitting the empty string "" is an empty
2256  * vector, not a vector containing a single string. The reason for this
2257  * special case is that being able to represent a empty vector is typically
2258  * more useful than consistent handling of empty elements. If you do need
2259  * to represent empty elements, you'll need to check for the empty string
2260  * before calling g_strsplit().
2261  *
2262  * Return value: a newly-allocated %NULL-terminated array of strings. Use
2263  *    g_strfreev() to free it.
2264  **/
2265 gchar**
2266 g_strsplit (const gchar *string,
2267             const gchar *delimiter,
2268             gint         max_tokens)
2269 {
2270   GSList *string_list = NULL, *slist;
2271   gchar **str_array, *s;
2272   guint n = 0;
2273   const gchar *remainder;
2274
2275   g_return_val_if_fail (string != NULL, NULL);
2276   g_return_val_if_fail (delimiter != NULL, NULL);
2277   g_return_val_if_fail (delimiter[0] != '\0', NULL);
2278
2279   if (max_tokens < 1)
2280     max_tokens = G_MAXINT;
2281
2282   remainder = string;
2283   s = strstr (remainder, delimiter);
2284   if (s)
2285     {
2286       gsize delimiter_len = strlen (delimiter);
2287
2288       while (--max_tokens && s)
2289         {
2290           gsize len;
2291
2292           len = s - remainder;
2293           string_list = g_slist_prepend (string_list,
2294                                          g_strndup (remainder, len));
2295           n++;
2296           remainder = s + delimiter_len;
2297           s = strstr (remainder, delimiter);
2298         }
2299     }
2300   if (*string)
2301     {
2302       n++;
2303       string_list = g_slist_prepend (string_list, g_strdup (remainder));
2304     }
2305
2306   str_array = g_new (gchar*, n + 1);
2307
2308   str_array[n--] = NULL;
2309   for (slist = string_list; slist; slist = slist->next)
2310     str_array[n--] = slist->data;
2311
2312   g_slist_free (string_list);
2313
2314   return str_array;
2315 }
2316
2317 /**
2318  * g_strsplit_set:
2319  * @string: The string to be tokenized
2320  * @delimiters: A nul-terminated string containing bytes that are used
2321  *              to split the string.
2322  * @max_tokens: The maximum number of tokens to split @string into.
2323  *              If this is less than 1, the string is split completely
2324  *
2325  * Splits @string into a number of tokens not containing any of the characters
2326  * in @delimiter. A token is the (possibly empty) longest string that does not
2327  * contain any of the characters in @delimiters. If @max_tokens is reached, the
2328  * remainder is appended to the last token.
2329  *
2330  * For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a
2331  * %NULL-terminated vector containing the three strings "abc", "def",
2332  * and "ghi".
2333  *
2334  * The result if g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated
2335  * vector containing the four strings "", "def", "ghi", and "".
2336  *
2337  * As a special case, the result of splitting the empty string "" is an empty
2338  * vector, not a vector containing a single string. The reason for this
2339  * special case is that being able to represent a empty vector is typically
2340  * more useful than consistent handling of empty elements. If you do need
2341  * to represent empty elements, you'll need to check for the empty string
2342  * before calling g_strsplit_set().
2343  *
2344  * Note that this function works on bytes not characters, so it can't be used
2345  * to delimit UTF-8 strings for anything but ASCII characters.
2346  *
2347  * Return value: a newly-allocated %NULL-terminated array of strings. Use
2348  *    g_strfreev() to free it.
2349  *
2350  * Since: 2.4
2351  **/
2352 gchar **
2353 g_strsplit_set (const gchar *string,
2354                 const gchar *delimiters,
2355                 gint         max_tokens)
2356 {
2357   gboolean delim_table[256];
2358   GSList *tokens, *list;
2359   gint n_tokens;
2360   const gchar *s;
2361   const gchar *current;
2362   gchar *token;
2363   gchar **result;
2364
2365   g_return_val_if_fail (string != NULL, NULL);
2366   g_return_val_if_fail (delimiters != NULL, NULL);
2367
2368   if (max_tokens < 1)
2369     max_tokens = G_MAXINT;
2370
2371   if (*string == '\0')
2372     {
2373       result = g_new (char *, 1);
2374       result[0] = NULL;
2375       return result;
2376     }
2377
2378   memset (delim_table, FALSE, sizeof (delim_table));
2379   for (s = delimiters; *s != '\0'; ++s)
2380     delim_table[*(guchar *)s] = TRUE;
2381
2382   tokens = NULL;
2383   n_tokens = 0;
2384
2385   s = current = string;
2386   while (*s != '\0')
2387     {
2388       if (delim_table[*(guchar *)s] && n_tokens + 1 < max_tokens)
2389         {
2390           gchar *token;
2391
2392           token = g_strndup (current, s - current);
2393           tokens = g_slist_prepend (tokens, token);
2394           ++n_tokens;
2395
2396           current = s + 1;
2397         }
2398
2399       ++s;
2400     }
2401
2402   token = g_strndup (current, s - current);
2403   tokens = g_slist_prepend (tokens, token);
2404   ++n_tokens;
2405
2406   result = g_new (gchar *, n_tokens + 1);
2407
2408   result[n_tokens] = NULL;
2409   for (list = tokens; list != NULL; list = list->next)
2410     result[--n_tokens] = list->data;
2411
2412   g_slist_free (tokens);
2413
2414   return result;
2415 }
2416
2417 /**
2418  * g_strfreev:
2419  * @str_array: a %NULL-terminated array of strings to free.
2420
2421  * Frees a %NULL-terminated array of strings, and the array itself.
2422  * If called on a %NULL value, g_strfreev() simply returns.
2423  **/
2424 void
2425 g_strfreev (gchar **str_array)
2426 {
2427   if (str_array)
2428     {
2429       int i;
2430
2431       for(i = 0; str_array[i] != NULL; i++)
2432         g_free(str_array[i]);
2433
2434       g_free (str_array);
2435     }
2436 }
2437
2438 /**
2439  * g_strdupv:
2440  * @str_array: %NULL-terminated array of strings.
2441  *
2442  * Copies %NULL-terminated array of strings. The copy is a deep copy;
2443  * the new array should be freed by first freeing each string, then
2444  * the array itself. g_strfreev() does this for you. If called
2445  * on a %NULL value, g_strdupv() simply returns %NULL.
2446  *
2447  * Return value: a new %NULL-terminated array of strings.
2448  **/
2449 gchar**
2450 g_strdupv (gchar **str_array)
2451 {
2452   if (str_array)
2453     {
2454       gint i;
2455       gchar **retval;
2456
2457       i = 0;
2458       while (str_array[i])
2459         ++i;
2460
2461       retval = g_new (gchar*, i + 1);
2462
2463       i = 0;
2464       while (str_array[i])
2465         {
2466           retval[i] = g_strdup (str_array[i]);
2467           ++i;
2468         }
2469       retval[i] = NULL;
2470
2471       return retval;
2472     }
2473   else
2474     return NULL;
2475 }
2476
2477 gchar*
2478 g_strjoinv (const gchar  *separator,
2479             gchar       **str_array)
2480 {
2481   gchar *string;
2482   gchar *ptr;
2483
2484   g_return_val_if_fail (str_array != NULL, NULL);
2485
2486   if (separator == NULL)
2487     separator = "";
2488
2489   if (*str_array)
2490     {
2491       gint i;
2492       gsize len;
2493       gsize separator_len;
2494
2495       separator_len = strlen (separator);
2496       /* First part, getting length */
2497       len = 1 + strlen (str_array[0]);
2498       for (i = 1; str_array[i] != NULL; i++)
2499         len += strlen (str_array[i]);
2500       len += separator_len * (i - 1);
2501
2502       /* Second part, building string */
2503       string = g_new (gchar, len);
2504       ptr = g_stpcpy (string, *str_array);
2505       for (i = 1; str_array[i] != NULL; i++)
2506         {
2507           ptr = g_stpcpy (ptr, separator);
2508           ptr = g_stpcpy (ptr, str_array[i]);
2509         }
2510       }
2511   else
2512     string = g_strdup ("");
2513
2514   return string;
2515 }
2516
2517 gchar*
2518 g_strjoin (const gchar  *separator,
2519            ...)
2520 {
2521   gchar *string, *s;
2522   va_list args;
2523   gsize len;
2524   gsize separator_len;
2525   gchar *ptr;
2526
2527   if (separator == NULL)
2528     separator = "";
2529
2530   separator_len = strlen (separator);
2531
2532   va_start (args, separator);
2533
2534   s = va_arg (args, gchar*);
2535
2536   if (s)
2537     {
2538       /* First part, getting length */
2539       len = 1 + strlen (s);
2540
2541       s = va_arg (args, gchar*);
2542       while (s)
2543         {
2544           len += separator_len + strlen (s);
2545           s = va_arg (args, gchar*);
2546         }
2547       va_end (args);
2548
2549       /* Second part, building string */
2550       string = g_new (gchar, len);
2551
2552       va_start (args, separator);
2553
2554       s = va_arg (args, gchar*);
2555       ptr = g_stpcpy (string, s);
2556
2557       s = va_arg (args, gchar*);
2558       while (s)
2559         {
2560           ptr = g_stpcpy (ptr, separator);
2561           ptr = g_stpcpy (ptr, s);
2562           s = va_arg (args, gchar*);
2563         }
2564     }
2565   else
2566     string = g_strdup ("");
2567
2568   va_end (args);
2569
2570   return string;
2571 }
2572
2573
2574 /**
2575  * g_strstr_len:
2576  * @haystack: a string.
2577  * @haystack_len: the maximum length of @haystack.
2578  * @needle: the string to search for.
2579  *
2580  * Searches the string @haystack for the first occurrence
2581  * of the string @needle, limiting the length of the search
2582  * to @haystack_len.
2583  *
2584  * Return value: a pointer to the found occurrence, or
2585  *    %NULL if not found.
2586  **/
2587 gchar *
2588 g_strstr_len (const gchar *haystack,
2589               gssize       haystack_len,
2590               const gchar *needle)
2591 {
2592   g_return_val_if_fail (haystack != NULL, NULL);
2593   g_return_val_if_fail (needle != NULL, NULL);
2594
2595   if (haystack_len < 0)
2596     return strstr (haystack, needle);
2597   else
2598     {
2599       const gchar *p = haystack;
2600       gsize needle_len = strlen (needle);
2601       const gchar *end;
2602       gsize i;
2603
2604       if (needle_len == 0)
2605         return (gchar *)haystack;
2606
2607       if (haystack_len < needle_len)
2608         return NULL;
2609
2610       end = haystack + haystack_len - needle_len;
2611
2612       while (*p && p <= end)
2613         {
2614           for (i = 0; i < needle_len; i++)
2615             if (p[i] != needle[i])
2616               goto next;
2617
2618           return (gchar *)p;
2619
2620         next:
2621           p++;
2622         }
2623
2624       return NULL;
2625     }
2626 }
2627
2628 /**
2629  * g_strrstr:
2630  * @haystack: a nul-terminated string.
2631  * @needle: the nul-terminated string to search for.
2632  *
2633  * Searches the string @haystack for the last occurrence
2634  * of the string @needle.
2635  *
2636  * Return value: a pointer to the found occurrence, or
2637  *    %NULL if not found.
2638  **/
2639 gchar *
2640 g_strrstr (const gchar *haystack,
2641            const gchar *needle)
2642 {
2643   gsize i;
2644   gsize needle_len;
2645   gsize haystack_len;
2646   const gchar *p;
2647
2648   g_return_val_if_fail (haystack != NULL, NULL);
2649   g_return_val_if_fail (needle != NULL, NULL);
2650
2651   needle_len = strlen (needle);
2652   haystack_len = strlen (haystack);
2653
2654   if (needle_len == 0)
2655     return (gchar *)haystack;
2656
2657   if (haystack_len < needle_len)
2658     return NULL;
2659
2660   p = haystack + haystack_len - needle_len;
2661
2662   while (p >= haystack)
2663     {
2664       for (i = 0; i < needle_len; i++)
2665         if (p[i] != needle[i])
2666           goto next;
2667
2668       return (gchar *)p;
2669
2670     next:
2671       p--;
2672     }
2673
2674   return NULL;
2675 }
2676
2677 /**
2678  * g_strrstr_len:
2679  * @haystack: a nul-terminated string.
2680  * @haystack_len: the maximum length of @haystack.
2681  * @needle: the nul-terminated string to search for.
2682  *
2683  * Searches the string @haystack for the last occurrence
2684  * of the string @needle, limiting the length of the search
2685  * to @haystack_len.
2686  *
2687  * Return value: a pointer to the found occurrence, or
2688  *    %NULL if not found.
2689  **/
2690 gchar *
2691 g_strrstr_len (const gchar *haystack,
2692                gssize        haystack_len,
2693                const gchar *needle)
2694 {
2695   g_return_val_if_fail (haystack != NULL, NULL);
2696   g_return_val_if_fail (needle != NULL, NULL);
2697
2698   if (haystack_len < 0)
2699     return g_strrstr (haystack, needle);
2700   else
2701     {
2702       gsize needle_len = strlen (needle);
2703       const gchar *haystack_max = haystack + haystack_len;
2704       const gchar *p = haystack;
2705       gsize i;
2706
2707       while (p < haystack_max && *p)
2708         p++;
2709
2710       if (p < haystack + needle_len)
2711         return NULL;
2712
2713       p -= needle_len;
2714
2715       while (p >= haystack)
2716         {
2717           for (i = 0; i < needle_len; i++)
2718             if (p[i] != needle[i])
2719               goto next;
2720
2721           return (gchar *)p;
2722
2723         next:
2724           p--;
2725         }
2726
2727       return NULL;
2728     }
2729 }
2730
2731
2732 /**
2733  * g_str_has_suffix:
2734  * @str: a nul-terminated string.
2735  * @suffix: the nul-terminated suffix to look for.
2736  *
2737  * Looks whether the string @str ends with @suffix.
2738  *
2739  * Return value: %TRUE if @str end with @suffix, %FALSE otherwise.
2740  *
2741  * Since: 2.2
2742  **/
2743 gboolean
2744 g_str_has_suffix (const gchar  *str,
2745                   const gchar  *suffix)
2746 {
2747   int str_len;
2748   int suffix_len;
2749
2750   g_return_val_if_fail (str != NULL, FALSE);
2751   g_return_val_if_fail (suffix != NULL, FALSE);
2752
2753   str_len = strlen (str);
2754   suffix_len = strlen (suffix);
2755
2756   if (str_len < suffix_len)
2757     return FALSE;
2758
2759   return strcmp (str + str_len - suffix_len, suffix) == 0;
2760 }
2761
2762 /**
2763  * g_str_has_prefix:
2764  * @str: a nul-terminated string.
2765  * @prefix: the nul-terminated prefix to look for.
2766  *
2767  * Looks whether the string @str begins with @prefix.
2768  *
2769  * Return value: %TRUE if @str begins with @prefix, %FALSE otherwise.
2770  *
2771  * Since: 2.2
2772  **/
2773 gboolean
2774 g_str_has_prefix (const gchar  *str,
2775                   const gchar  *prefix)
2776 {
2777   int str_len;
2778   int prefix_len;
2779
2780   g_return_val_if_fail (str != NULL, FALSE);
2781   g_return_val_if_fail (prefix != NULL, FALSE);
2782
2783   str_len = strlen (str);
2784   prefix_len = strlen (prefix);
2785
2786   if (str_len < prefix_len)
2787     return FALSE;
2788
2789   return strncmp (str, prefix, prefix_len) == 0;
2790 }
2791
2792
2793 /**
2794  * g_strip_context:
2795  * @msgid: a string
2796  * @msgval: another string
2797  *
2798  * An auxiliary function for gettext() support (see Q_()).
2799  *
2800  * Return value: @msgval, unless @msgval is identical to @msgid and contains
2801  *   a '|' character, in which case a pointer to the substring of msgid after
2802  *   the first '|' character is returned.
2803  *
2804  * Since: 2.4
2805  **/
2806 G_CONST_RETURN gchar *
2807 g_strip_context  (const gchar *msgid,
2808                   const gchar *msgval)
2809 {
2810   if (msgval == msgid)
2811     {
2812       const char *c = strchr (msgid, '|');
2813       if (c != NULL)
2814         return c + 1;
2815     }
2816
2817   return msgval;
2818 }
2819
2820
2821 /**
2822  * g_strv_length:
2823  * @str_array: a %NULL-terminated array of strings.
2824  *
2825  * Returns the length of the given %NULL-terminated
2826  * string array @str_array.
2827  *
2828  * Return value: length of @str_array.
2829  *
2830  * Since: 2.6
2831  **/
2832 guint
2833 g_strv_length (gchar **str_array)
2834 {
2835   guint i = 0;
2836
2837   g_return_val_if_fail (str_array != NULL, 0);
2838
2839   while (str_array[i])
2840     ++i;
2841
2842   return i;
2843 }
2844
2845 #define __G_STRFUNCS_C__
2846 #include "galiasdef.c"