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