1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
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.
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.
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.
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/.
40 #include <ctype.h> /* For tolower() */
42 #ifdef HAVE_XLOCALE_H
\r
43 /* Needed on BSD/OS X for e.g. strtod_l */
\r
44 #include <xlocale.h>
\r
51 /* do not include <unistd.h> here, it may interfere with g_strsignal() */
53 #include "gstrfuncs.h"
56 #include "gprintfint.h"
61 * SECTION:string_utils
62 * @title: String Utility Functions
63 * @short_description: various string-related functions
65 * This section describes a number of utility functions for creating,
66 * duplicating, and manipulating strings.
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><glib/gprintf.h></literal> in order to use the GLib
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>%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>%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>%Ns</literal>. If your intention is
87 * to format strings for a certain number of columns, then
88 * <literal>%Ns</literal> is not a correct solution anyway, since it
89 * fails to take wide characters (see g_unichar_iswide()) into account.
97 * Determines whether a character is alphanumeric.
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.
106 * Returns: %TRUE if @c is an ASCII alphanumeric character
113 * Determines whether a character is alphabetic (i.e. a letter).
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.
122 * Returns: %TRUE if @c is an ASCII alphabetic character
129 * Determines whether a character is a control character.
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.
138 * Returns: %TRUE if @c is an ASCII control character.
145 * Determines whether a character is digit (0-9).
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.
152 * Returns: %TRUE if @c is an ASCII digit.
159 * Determines whether a character is a printing character and not a space.
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.
168 * Returns: %TRUE if @c is an ASCII printing character other than space.
175 * Determines whether a character is an ASCII lower case letter.
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.
185 * Returns: %TRUE if @c is an ASCII lower case letter
192 * Determines whether a character is a printing character.
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.
201 * Returns: %TRUE if @c is an ASCII printing character.
208 * Determines whether a character is a punctuation character.
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.
217 * Returns: %TRUE if @c is an ASCII punctuation character.
224 * Determines whether a character is a white-space character.
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.
233 * Returns: %TRUE if @c is an ASCII white-space character
240 * Determines whether a character is an ASCII upper case letter.
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
250 * Returns: %TRUE if @c is an ASCII upper case letter
257 * Determines whether a character is a hexadecimal-digit character.
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.
264 * Returns: %TRUE if @c is an ASCII hexadecimal-digit character.
268 * G_ASCII_DTOSTR_BUF_SIZE:
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.
274 * The typical usage would be something like:
276 * char buf[G_ASCII_DTOSTR_BUF_SIZE];
278 * fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));
284 * @string: a string to remove the leading and trailing whitespace from
286 * Removes leading and trailing whitespace from a string.
287 * See g_strchomp() and g_strchug().
295 * The standard delimiters, used in g_strdelimit().
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 */
318 const guint16 * const g_ascii_table = ascii_table_data;
320 #ifdef HAVE_NEWLOCALE
324 static gsize initialized = FALSE;
325 static locale_t C_locale = NULL;
327 if (g_once_init_enter (&initialized))
329 C_locale = newlocale (LC_ALL_MASK, "C", NULL);
330 g_once_init_leave (&initialized, TRUE);
339 * @str: the string to duplicate
341 * Duplicates a string. If @str is %NULL it returns %NULL.
342 * The returned string should be freed with g_free()
343 * when no longer needed.
345 * Returns: a newly-allocated copy of @str
348 g_strdup (const gchar *str)
355 length = strlen (str) + 1;
356 new_str = g_new (char, length);
357 memcpy (new_str, str, length);
367 * @mem: the memory to copy.
368 * @byte_size: the number of bytes to copy.
370 * Allocates @byte_size bytes of memory, and copies @byte_size bytes into it
371 * from @mem. If @mem is %NULL it returns %NULL.
373 * Returns: a pointer to the newly-allocated copy of the memory, or %NULL if @mem
377 g_memdup (gconstpointer mem,
384 new_mem = g_malloc (byte_size);
385 memcpy (new_mem, mem, byte_size);
395 * @str: the string to duplicate
396 * @n: the maximum number of bytes to copy from @str
398 * Duplicates the first @n bytes of a string, returning a newly-allocated
399 * buffer @n + 1 bytes long which will always be nul-terminated.
400 * If @str is less than @n bytes long the buffer is padded with nuls.
401 * If @str is %NULL it returns %NULL.
402 * The returned value should be freed when no longer needed.
405 * To copy a number of characters from a UTF-8 encoded string, use
406 * g_utf8_strncpy() instead.
409 * Returns: a newly-allocated buffer containing the first @n bytes
410 * of @str, nul-terminated
413 g_strndup (const gchar *str,
420 new_str = g_new (gchar, n + 1);
421 strncpy (new_str, str, n);
432 * @length: the length of the new string
433 * @fill_char: the byte to fill the string with
435 * Creates a new string @length bytes long filled with @fill_char.
436 * The returned string should be freed when no longer needed.
438 * Returns: a newly-allocated string filled the @fill_char
441 g_strnfill (gsize length,
446 str = g_new (gchar, length + 1);
447 memset (str, (guchar)fill_char, length);
455 * @dest: destination buffer.
456 * @src: source string.
458 * Copies a nul-terminated string into the dest buffer, include the
459 * trailing nul, and return a pointer to the trailing nul byte.
460 * This is useful for concatenating multiple strings together
461 * without having to repeatedly scan for the end.
463 * Return value: a pointer to trailing nul byte.
466 g_stpcpy (gchar *dest,
470 g_return_val_if_fail (dest != NULL, NULL);
471 g_return_val_if_fail (src != NULL, NULL);
472 return stpcpy (dest, src);
474 register gchar *d = dest;
475 register const gchar *s = src;
477 g_return_val_if_fail (dest != NULL, NULL);
478 g_return_val_if_fail (src != NULL, NULL);
481 while (*s++ != '\0');
489 * @format: a standard printf() format string, but notice
490 * <link linkend="string-precision">string precision pitfalls</link>
491 * @args: the list of parameters to insert into the format string
493 * Similar to the standard C vsprintf() function but safer, since it
494 * calculates the maximum space required and allocates memory to hold
495 * the result. The returned string should be freed with g_free() when
498 * See also g_vasprintf(), which offers the same functionality, but
499 * additionally returns the length of the allocated string.
501 * Returns: a newly-allocated string holding the result
504 g_strdup_vprintf (const gchar *format,
507 gchar *string = NULL;
509 g_vasprintf (&string, format, args);
516 * @format: a standard printf() format string, but notice
517 * <link linkend="string-precision">string precision pitfalls</link>
518 * @...: the parameters to insert into the format string
520 * Similar to the standard C sprintf() function but safer, since it
521 * calculates the maximum space required and allocates memory to hold
522 * the result. The returned string should be freed with g_free() when no
525 * Returns: a newly-allocated string holding the result
528 g_strdup_printf (const gchar *format,
534 va_start (args, format);
535 buffer = g_strdup_vprintf (format, args);
543 * @string1: the first string to add, which must not be %NULL
544 * @...: a %NULL-terminated list of strings to append to the string
546 * Concatenates all of the given strings into one long string.
547 * The returned string should be freed with g_free() when no longer needed.
549 * Note that this function is usually not the right function to use to
550 * assemble a translated message from pieces, since proper translation
551 * often requires the pieces to be reordered.
553 * <warning><para>The variable argument list <emphasis>must</emphasis> end
554 * with %NULL. If you forget the %NULL, g_strconcat() will start appending
555 * random memory junk to your string.</para></warning>
557 * Returns: a newly-allocated string containing all the string arguments
560 g_strconcat (const gchar *string1, ...)
571 l = 1 + strlen (string1);
572 va_start (args, string1);
573 s = va_arg (args, gchar*);
577 s = va_arg (args, gchar*);
581 concat = g_new (gchar, l);
584 ptr = g_stpcpy (ptr, string1);
585 va_start (args, string1);
586 s = va_arg (args, gchar*);
589 ptr = g_stpcpy (ptr, s);
590 s = va_arg (args, gchar*);
599 * @nptr: the string to convert to a numeric value.
600 * @endptr: if non-%NULL, it returns the character after
601 * the last character used in the conversion.
603 * Converts a string to a #gdouble value.
604 * It calls the standard strtod() function to handle the conversion, but
605 * if the string is not completely converted it attempts the conversion
606 * again with g_ascii_strtod(), and returns the best match.
608 * This function should seldom be used. The normal situation when reading
609 * numbers not for human consumption is to use g_ascii_strtod(). Only when
610 * you know that you must expect both locale formatted and C formatted numbers
611 * should you use this. Make sure that you don't pass strings such as comma
612 * separated lists of values, since the commas may be interpreted as a decimal
613 * point in some locales, causing unexpected results.
615 * Return value: the #gdouble value.
618 g_strtod (const gchar *nptr,
626 g_return_val_if_fail (nptr != NULL, 0);
631 val_1 = strtod (nptr, &fail_pos_1);
633 if (fail_pos_1 && fail_pos_1[0] != 0)
634 val_2 = g_ascii_strtod (nptr, &fail_pos_2);
636 if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)
639 *endptr = fail_pos_1;
645 *endptr = fail_pos_2;
652 * @nptr: the string to convert to a numeric value.
653 * @endptr: if non-%NULL, it returns the character after
654 * the last character used in the conversion.
656 * Converts a string to a #gdouble value.
658 * This function behaves like the standard strtod() function
659 * does in the C locale. It does this without actually changing
660 * the current locale, since that would not be thread-safe.
661 * A limitation of the implementation is that this function
662 * will still accept localized versions of infinities and NANs.
664 * This function is typically used when reading configuration
665 * files or other non-user input that should be locale independent.
666 * To handle input from the user you should normally use the
667 * locale-sensitive system strtod() function.
669 * To convert from a #gdouble to a string in a locale-insensitive
670 * way, use g_ascii_dtostr().
672 * If the correct value would cause overflow, plus or minus <literal>HUGE_VAL</literal>
673 * is returned (according to the sign of the value), and <literal>ERANGE</literal> is
674 * stored in <literal>errno</literal>. If the correct value would cause underflow,
675 * zero is returned and <literal>ERANGE</literal> is stored in <literal>errno</literal>.
677 * This function resets <literal>errno</literal> before calling strtod() so that
678 * you can reliably detect overflow and underflow.
680 * Return value: the #gdouble value.
683 g_ascii_strtod (const gchar *nptr,
688 g_return_val_if_fail (nptr != NULL, 0);
692 return strtod_l (nptr, endptr, get_C_locale ());
698 struct lconv *locale_data;
699 const char *decimal_point;
700 int decimal_point_len;
701 const char *p, *decimal_point_pos;
702 const char *end = NULL; /* Silence gcc */
705 g_return_val_if_fail (nptr != NULL, 0);
709 locale_data = localeconv ();
710 decimal_point = locale_data->decimal_point;
711 decimal_point_len = strlen (decimal_point);
713 g_assert (decimal_point_len != 0);
715 decimal_point_pos = NULL;
718 if (decimal_point[0] != '.' ||
719 decimal_point[1] != 0)
722 /* Skip leading space */
723 while (g_ascii_isspace (*p))
726 /* Skip leading optional sign */
727 if (*p == '+' || *p == '-')
731 (p[1] == 'x' || p[1] == 'X'))
734 /* HEX - find the (optional) decimal point */
736 while (g_ascii_isxdigit (*p))
740 decimal_point_pos = p++;
742 while (g_ascii_isxdigit (*p))
745 if (*p == 'p' || *p == 'P')
747 if (*p == '+' || *p == '-')
749 while (g_ascii_isdigit (*p))
754 else if (g_ascii_isdigit (*p) || *p == '.')
756 while (g_ascii_isdigit (*p))
760 decimal_point_pos = p++;
762 while (g_ascii_isdigit (*p))
765 if (*p == 'e' || *p == 'E')
767 if (*p == '+' || *p == '-')
769 while (g_ascii_isdigit (*p))
774 /* For the other cases, we need not convert the decimal point */
777 if (decimal_point_pos)
781 /* We need to convert the '.' to the locale specific decimal point */
782 copy = g_malloc (end - nptr + 1 + decimal_point_len);
785 memcpy (c, nptr, decimal_point_pos - nptr);
786 c += decimal_point_pos - nptr;
787 memcpy (c, decimal_point, decimal_point_len);
788 c += decimal_point_len;
789 memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1));
790 c += end - (decimal_point_pos + 1);
794 val = strtod (copy, &fail_pos);
795 strtod_errno = errno;
799 if (fail_pos - copy > decimal_point_pos - nptr)
800 fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);
802 fail_pos = (char *)nptr + (fail_pos - copy);
812 copy = g_malloc (end - (char *)nptr + 1);
813 memcpy (copy, nptr, end - nptr);
814 *(copy + (end - (char *)nptr)) = 0;
817 val = strtod (copy, &fail_pos);
818 strtod_errno = errno;
822 fail_pos = (char *)nptr + (fail_pos - copy);
830 val = strtod (nptr, &fail_pos);
831 strtod_errno = errno;
837 errno = strtod_errno;
846 * @buffer: A buffer to place the resulting string in
847 * @buf_len: The length of the buffer.
848 * @d: The #gdouble to convert
850 * Converts a #gdouble to a string, using the '.' as
853 * This functions generates enough precision that converting
854 * the string back using g_ascii_strtod() gives the same machine-number
855 * (on machines with IEEE compatible 64bit doubles). It is
856 * guaranteed that the size of the resulting string will never
857 * be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes.
859 * Return value: The pointer to the buffer with the converted string.
862 g_ascii_dtostr (gchar *buffer,
866 return g_ascii_formatd (buffer, buf_len, "%.17g", d);
871 * @buffer: A buffer to place the resulting string in
872 * @buf_len: The length of the buffer.
873 * @format: The printf()-style format to use for the
874 * code to use for converting.
875 * @d: The #gdouble to convert
877 * Converts a #gdouble to a string, using the '.' as
878 * decimal point. To format the number you pass in
879 * a printf()-style format string. Allowed conversion
880 * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
882 * If you just want to want to serialize the value into a
883 * string, use g_ascii_dtostr().
885 * Return value: The pointer to the buffer with the converted string.
888 g_ascii_formatd (gchar *buffer,
893 #ifdef HAVE_USELOCALE
896 old_locale = uselocale (get_C_locale ());
897 _g_snprintf (buffer, buf_len, format, d);
898 uselocale (old_locale);
902 struct lconv *locale_data;
903 const char *decimal_point;
904 int decimal_point_len;
909 g_return_val_if_fail (buffer != NULL, NULL);
910 g_return_val_if_fail (format[0] == '%', NULL);
911 g_return_val_if_fail (strpbrk (format + 1, "'l%") == NULL, NULL);
913 format_char = format[strlen (format) - 1];
915 g_return_val_if_fail (format_char == 'e' || format_char == 'E' ||
916 format_char == 'f' || format_char == 'F' ||
917 format_char == 'g' || format_char == 'G',
920 if (format[0] != '%')
923 if (strpbrk (format + 1, "'l%"))
926 if (!(format_char == 'e' || format_char == 'E' ||
927 format_char == 'f' || format_char == 'F' ||
928 format_char == 'g' || format_char == 'G'))
931 _g_snprintf (buffer, buf_len, format, d);
933 locale_data = localeconv ();
934 decimal_point = locale_data->decimal_point;
935 decimal_point_len = strlen (decimal_point);
937 g_assert (decimal_point_len != 0);
939 if (decimal_point[0] != '.' ||
940 decimal_point[1] != 0)
944 while (g_ascii_isspace (*p))
947 if (*p == '+' || *p == '-')
950 while (isdigit ((guchar)*p))
953 if (strncmp (p, decimal_point, decimal_point_len) == 0)
957 if (decimal_point_len > 1)
959 rest_len = strlen (p + (decimal_point_len-1));
960 memmove (p, p + (decimal_point_len-1), rest_len);
970 #define ISSPACE(c) ((c) == ' ' || (c) == '\f' || (c) == '\n' || \
971 (c) == '\r' || (c) == '\t' || (c) == '\v')
972 #define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
973 #define ISLOWER(c) ((c) >= 'a' && (c) <= 'z')
974 #define ISALPHA(c) (ISUPPER (c) || ISLOWER (c))
975 #define TOUPPER(c) (ISLOWER (c) ? (c) - 'a' + 'A' : (c))
976 #define TOLOWER(c) (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
978 #if !defined(HAVE_STRTOLL_L) || !defined(HAVE_STRTOULL_L)
981 g_parse_long_long (const gchar *nptr,
982 const gchar **endptr,
986 /* this code is based on on the strtol(3) code from GNU libc released under
987 * the GNU Lesser General Public License.
989 * Copyright (C) 1991,92,94,95,96,97,98,99,2000,01,02
990 * Free Software Foundation, Inc.
996 const gchar *s, *save;
999 g_return_val_if_fail (nptr != NULL, 0);
1002 if (base == 1 || base > 36)
1012 /* Skip white space. */
1013 while (ISSPACE (*s))
1016 if (G_UNLIKELY (!*s))
1019 /* Check for a sign. */
1028 /* Recognize number prefix and if BASE is zero, figure it out ourselves. */
1031 if ((base == 0 || base == 16) && TOUPPER (s[1]) == 'X')
1042 /* Save the pointer so we can check later if anything happened. */
1044 cutoff = G_MAXUINT64 / base;
1045 cutlim = G_MAXUINT64 % base;
1052 if (c >= '0' && c <= '9')
1054 else if (ISALPHA (c))
1055 c = TOUPPER (c) - 'A' + 10;
1060 /* Check for overflow. */
1061 if (ui64 > cutoff || (ui64 == cutoff && c > cutlim))
1070 /* Check if anything actually happened. */
1074 /* Store in ENDPTR the address of one character
1075 past the last character we converted. */
1079 if (G_UNLIKELY (overflow))
1088 /* We must handle a special case here: the base is 0 or 16 and the
1089 first two characters are '0' and 'x', but the rest are no
1090 hexadecimal digits. This is no error case. We return 0 and
1091 ENDPTR points to the `x`. */
1094 if (save - nptr >= 2 && TOUPPER (save[-1]) == 'X'
1096 *endptr = &save[-1];
1098 /* There was no number to convert. */
1107 * @nptr: the string to convert to a numeric value.
1108 * @endptr: if non-%NULL, it returns the character after
1109 * the last character used in the conversion.
1110 * @base: to be used for the conversion, 2..36 or 0
1112 * Converts a string to a #guint64 value.
1113 * This function behaves like the standard strtoull() function
1114 * does in the C locale. It does this without actually
1115 * changing the current locale, since that would not be
1118 * This function is typically used when reading configuration
1119 * files or other non-user input that should be locale independent.
1120 * To handle input from the user you should normally use the
1121 * locale-sensitive system strtoull() function.
1123 * If the correct value would cause overflow, %G_MAXUINT64
1124 * is returned, and <literal>ERANGE</literal> is stored in <literal>errno</literal>.
1125 * If the base is outside the valid range, zero is returned, and
1126 * <literal>EINVAL</literal> is stored in <literal>errno</literal>.
1127 * If the string conversion fails, zero is returned, and @endptr returns
1128 * @nptr (if @endptr is non-%NULL).
1130 * Return value: the #guint64 value or zero on error.
1135 g_ascii_strtoull (const gchar *nptr,
1139 #ifdef HAVE_STRTOULL_L
1140 return strtoull_l (nptr, endptr, base, get_C_locale ());
1145 result = g_parse_long_long (nptr, (const gchar **) endptr, base, &negative);
1147 /* Return the result of the appropriate sign. */
1148 return negative ? -result : result;
1154 * @nptr: the string to convert to a numeric value.
1155 * @endptr: if non-%NULL, it returns the character after
1156 * the last character used in the conversion.
1157 * @base: to be used for the conversion, 2..36 or 0
1159 * Converts a string to a #gint64 value.
1160 * This function behaves like the standard strtoll() function
1161 * does in the C locale. It does this without actually
1162 * changing the current locale, since that would not be
1165 * This function is typically used when reading configuration
1166 * files or other non-user input that should be locale independent.
1167 * To handle input from the user you should normally use the
1168 * locale-sensitive system strtoll() function.
1170 * If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64
1171 * is returned, and <literal>ERANGE</literal> is stored in <literal>errno</literal>.
1172 * If the base is outside the valid range, zero is returned, and
1173 * <literal>EINVAL</literal> is stored in <literal>errno</literal>. If the
1174 * string conversion fails, zero is returned, and @endptr returns @nptr
1175 * (if @endptr is non-%NULL).
1177 * Return value: the #gint64 value or zero on error.
1182 g_ascii_strtoll (const gchar *nptr,
1186 #ifdef HAVE_STRTOLL_L
1187 return strtoll_l (nptr, endptr, base, get_C_locale ());
1192 result = g_parse_long_long (nptr, (const gchar **) endptr, base, &negative);
1194 if (negative && result > (guint64) G_MININT64)
1199 else if (!negative && result > (guint64) G_MAXINT64)
1205 return - (gint64) result;
1207 return (gint64) result;
1213 * @errnum: the system error number. See the standard C %errno
1216 * Returns a string corresponding to the given error code, e.g.
1217 * "no such process". You should use this function in preference to
1218 * strerror(), because it returns a string in UTF-8 encoding, and since
1219 * not all platforms support the strerror() function.
1221 * Returns: a UTF-8 string describing the error code. If the error code
1222 * is unknown, it returns "unknown error (<code>)".
1225 g_strerror (gint errnum)
1231 gint saved_errno = errno;
1233 msg = tofree = NULL;
1235 #ifdef HAVE_STRERROR
1236 msg = strerror (errnum);
1237 if (!g_get_charset (NULL))
1238 msg = tofree = g_locale_to_utf8 (msg, -1, NULL, NULL, NULL);
1244 _g_sprintf (msg, "unknown error (%d)", errnum);
1247 ret = g_intern_string (msg);
1249 errno = saved_errno;
1255 * @signum: the signal number. See the <literal>signal</literal>
1258 * Returns a string describing the given signal, e.g. "Segmentation fault".
1259 * You should use this function in preference to strsignal(), because it
1260 * returns a string in UTF-8 encoding, and since not all platforms support
1261 * the strsignal() function.
1263 * Returns: a UTF-8 string describing the signal. If the signal is unknown,
1264 * it returns "unknown signal (<signum>)".
1267 g_strsignal (gint signum)
1273 msg = tofree = NULL;
1275 #ifdef HAVE_STRSIGNAL
1276 msg = strsignal (signum);
1277 if (!g_get_charset (NULL))
1278 msg = tofree = g_locale_to_utf8 (msg, -1, NULL, NULL, NULL);
1282 msg = tofree = g_strdup_printf ("unknown signal (%d)", signum);
1283 ret = g_intern_string (msg);
1289 /* Functions g_strlcpy and g_strlcat were originally developed by
1290 * Todd C. Miller <Todd.Miller@courtesan.com> to simplify writing secure code.
1291 * See http://www.openbsd.org/cgi-bin/man.cgi?query=strlcpy
1292 * for more information.
1296 /* Use the native ones, if available; they might be implemented in assembly */
1298 g_strlcpy (gchar *dest,
1302 g_return_val_if_fail (dest != NULL, 0);
1303 g_return_val_if_fail (src != NULL, 0);
1305 return strlcpy (dest, src, dest_size);
1309 g_strlcat (gchar *dest,
1313 g_return_val_if_fail (dest != NULL, 0);
1314 g_return_val_if_fail (src != NULL, 0);
1316 return strlcat (dest, src, dest_size);
1319 #else /* ! HAVE_STRLCPY */
1322 * @dest: destination buffer
1323 * @src: source buffer
1324 * @dest_size: length of @dest in bytes
1326 * Portability wrapper that calls strlcpy() on systems which have it,
1327 * and emulates strlcpy() otherwise. Copies @src to @dest; @dest is
1328 * guaranteed to be nul-terminated; @src must be nul-terminated;
1329 * @dest_size is the buffer size, not the number of chars to copy.
1331 * At most dest_size - 1 characters will be copied. Always nul-terminates
1332 * (unless dest_size == 0). This function does <emphasis>not</emphasis>
1333 * allocate memory. Unlike strncpy(), this function doesn't pad dest (so
1334 * it's often faster). It returns the size of the attempted result,
1335 * strlen (src), so if @retval >= @dest_size, truncation occurred.
1337 * <note><para>Caveat: strlcpy() is supposedly more secure than
1338 * strcpy() or strncpy(), but if you really want to avoid screwups,
1339 * g_strdup() is an even better idea.</para></note>
1341 * Returns: length of @src
1344 g_strlcpy (gchar *dest,
1348 register gchar *d = dest;
1349 register const gchar *s = src;
1350 register gsize n = dest_size;
1352 g_return_val_if_fail (dest != NULL, 0);
1353 g_return_val_if_fail (src != NULL, 0);
1355 /* Copy as many bytes as will fit */
1356 if (n != 0 && --n != 0)
1359 register gchar c = *s++;
1367 /* If not enough room in dest, add NUL and traverse rest of src */
1376 return s - src - 1; /* count does not include NUL */
1381 * @dest: destination buffer, already containing one nul-terminated string
1382 * @src: source buffer
1383 * @dest_size: length of @dest buffer in bytes (not length of existing string
1386 * Portability wrapper that calls strlcat() on systems which have it,
1387 * and emulates it otherwise. Appends nul-terminated @src string to @dest,
1388 * guaranteeing nul-termination for @dest. The total size of @dest won't
1389 * exceed @dest_size.
1391 * At most dest_size - 1 characters will be copied.
1392 * Unlike strncat, dest_size is the full size of dest, not the space left over.
1393 * This function does NOT allocate memory.
1394 * This always NUL terminates (unless siz == 0 or there were no NUL characters
1395 * in the dest_size characters of dest to start with).
1397 * <note><para>Caveat: this is supposedly a more secure alternative to
1398 * strcat() or strncat(), but for real security g_strconcat() is harder
1399 * to mess up.</para></note>
1401 * Returns: size of attempted result, which is MIN (dest_size, strlen
1402 * (original dest)) + strlen (src), so if retval >= dest_size,
1403 * truncation occurred.
1406 g_strlcat (gchar *dest,
1410 register gchar *d = dest;
1411 register const gchar *s = src;
1412 register gsize bytes_left = dest_size;
1413 gsize dlength; /* Logically, MIN (strlen (d), dest_size) */
1415 g_return_val_if_fail (dest != NULL, 0);
1416 g_return_val_if_fail (src != NULL, 0);
1418 /* Find the end of dst and adjust bytes left but don't go past end */
1419 while (*d != 0 && bytes_left-- != 0)
1422 bytes_left = dest_size - dlength;
1424 if (bytes_left == 0)
1425 return dlength + strlen (s);
1429 if (bytes_left != 1)
1438 return dlength + (s - src); /* count does not include NUL */
1440 #endif /* ! HAVE_STRLCPY */
1445 * @len: length of @str in bytes, or -1 if @str is nul-terminated.
1447 * Converts all upper case ASCII letters to lower case ASCII letters.
1449 * Return value: a newly-allocated string, with all the upper case
1450 * characters in @str converted to lower case, with
1451 * semantics that exactly match g_ascii_tolower(). (Note
1452 * that this is unlike the old g_strdown(), which modified
1453 * the string in place.)
1456 g_ascii_strdown (const gchar *str,
1461 g_return_val_if_fail (str != NULL, NULL);
1466 result = g_strndup (str, len);
1467 for (s = result; *s; s++)
1468 *s = g_ascii_tolower (*s);
1476 * @len: length of @str in bytes, or -1 if @str is nul-terminated.
1478 * Converts all lower case ASCII letters to upper case ASCII letters.
1480 * Return value: a newly allocated string, with all the lower case
1481 * characters in @str converted to upper case, with
1482 * semantics that exactly match g_ascii_toupper(). (Note
1483 * that this is unlike the old g_strup(), which modified
1484 * the string in place.)
1487 g_ascii_strup (const gchar *str,
1492 g_return_val_if_fail (str != NULL, NULL);
1497 result = g_strndup (str, len);
1498 for (s = result; *s; s++)
1499 *s = g_ascii_toupper (*s);
1506 * @string: the string to convert.
1508 * Converts a string to lower case.
1510 * Return value: the string
1512 * Deprecated:2.2: This function is totally broken for the reasons discussed
1513 * in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown()
1517 g_strdown (gchar *string)
1521 g_return_val_if_fail (string != NULL, NULL);
1523 s = (guchar *) string;
1532 return (gchar *) string;
1537 * @string: the string to convert.
1539 * Converts a string to upper case.
1541 * Return value: the string
1543 * Deprecated:2.2: This function is totally broken for the reasons discussed
1544 * in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.
1547 g_strup (gchar *string)
1551 g_return_val_if_fail (string != NULL, NULL);
1553 s = (guchar *) string;
1562 return (gchar *) string;
1567 * @string: the string to reverse
1569 * Reverses all of the bytes in a string. For example,
1570 * <literal>g_strreverse ("abcdef")</literal> will result
1573 * Note that g_strreverse() doesn't work on UTF-8 strings
1574 * containing multibyte characters. For that purpose, use
1575 * g_utf8_strreverse().
1577 * Returns: the same pointer passed in as @string
1580 g_strreverse (gchar *string)
1582 g_return_val_if_fail (string != NULL, NULL);
1586 register gchar *h, *t;
1589 t = string + strlen (string) - 1;
1608 * @c: any character.
1610 * Convert a character to ASCII lower case.
1612 * Unlike the standard C library tolower() function, this only
1613 * recognizes standard ASCII letters and ignores the locale, returning
1614 * all non-ASCII characters unchanged, even if they are lower case
1615 * letters in a particular character set. Also unlike the standard
1616 * library function, this takes and returns a char, not an int, so
1617 * don't call it on <literal>EOF</literal> but no need to worry about casting to #guchar
1618 * before passing a possibly non-ASCII character in.
1620 * Return value: the result of converting @c to lower case.
1621 * If @c is not an ASCII upper case letter,
1622 * @c is returned unchanged.
1625 g_ascii_tolower (gchar c)
1627 return g_ascii_isupper (c) ? c - 'A' + 'a' : c;
1632 * @c: any character.
1634 * Convert a character to ASCII upper case.
1636 * Unlike the standard C library toupper() function, this only
1637 * recognizes standard ASCII letters and ignores the locale, returning
1638 * all non-ASCII characters unchanged, even if they are upper case
1639 * letters in a particular character set. Also unlike the standard
1640 * library function, this takes and returns a char, not an int, so
1641 * don't call it on <literal>EOF</literal> but no need to worry about casting to #guchar
1642 * before passing a possibly non-ASCII character in.
1644 * Return value: the result of converting @c to upper case.
1645 * If @c is not an ASCII lower case letter,
1646 * @c is returned unchanged.
1649 g_ascii_toupper (gchar c)
1651 return g_ascii_islower (c) ? c - 'a' + 'A' : c;
1655 * g_ascii_digit_value:
1656 * @c: an ASCII character.
1658 * Determines the numeric value of a character as a decimal
1659 * digit. Differs from g_unichar_digit_value() because it takes
1660 * a char, so there's no worry about sign extension if characters
1663 * Return value: If @c is a decimal digit (according to
1664 * g_ascii_isdigit()), its numeric value. Otherwise, -1.
1667 g_ascii_digit_value (gchar c)
1669 if (g_ascii_isdigit (c))
1675 * g_ascii_xdigit_value:
1676 * @c: an ASCII character.
1678 * Determines the numeric value of a character as a hexidecimal
1679 * digit. Differs from g_unichar_xdigit_value() because it takes
1680 * a char, so there's no worry about sign extension if characters
1683 * Return value: If @c is a hex digit (according to
1684 * g_ascii_isxdigit()), its numeric value. Otherwise, -1.
1687 g_ascii_xdigit_value (gchar c)
1689 if (c >= 'A' && c <= 'F')
1690 return c - 'A' + 10;
1691 if (c >= 'a' && c <= 'f')
1692 return c - 'a' + 10;
1693 return g_ascii_digit_value (c);
1697 * g_ascii_strcasecmp:
1698 * @s1: string to compare with @s2.
1699 * @s2: string to compare with @s1.
1701 * Compare two strings, ignoring the case of ASCII characters.
1703 * Unlike the BSD strcasecmp() function, this only recognizes standard
1704 * ASCII letters and ignores the locale, treating all non-ASCII
1705 * bytes as if they are not letters.
1707 * This function should be used only on strings that are known to be
1708 * in encodings where the bytes corresponding to ASCII letters always
1709 * represent themselves. This includes UTF-8 and the ISO-8859-*
1710 * charsets, but not for instance double-byte encodings like the
1711 * Windows Codepage 932, where the trailing bytes of double-byte
1712 * characters include all ASCII letters. If you compare two CP932
1713 * strings using this function, you will get false matches.
1715 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1716 * or a positive value if @s1 > @s2.
1719 g_ascii_strcasecmp (const gchar *s1,
1724 g_return_val_if_fail (s1 != NULL, 0);
1725 g_return_val_if_fail (s2 != NULL, 0);
1729 c1 = (gint)(guchar) TOLOWER (*s1);
1730 c2 = (gint)(guchar) TOLOWER (*s2);
1736 return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
1740 * g_ascii_strncasecmp:
1741 * @s1: string to compare with @s2.
1742 * @s2: string to compare with @s1.
1743 * @n: number of characters to compare.
1745 * Compare @s1 and @s2, ignoring the case of ASCII characters and any
1746 * characters after the first @n in each string.
1748 * Unlike the BSD strcasecmp() function, this only recognizes standard
1749 * ASCII letters and ignores the locale, treating all non-ASCII
1750 * characters as if they are not letters.
1752 * The same warning as in g_ascii_strcasecmp() applies: Use this
1753 * function only on strings known to be in encodings where bytes
1754 * corresponding to ASCII letters always represent themselves.
1756 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1757 * or a positive value if @s1 > @s2.
1760 g_ascii_strncasecmp (const gchar *s1,
1766 g_return_val_if_fail (s1 != NULL, 0);
1767 g_return_val_if_fail (s2 != NULL, 0);
1769 while (n && *s1 && *s2)
1772 c1 = (gint)(guchar) TOLOWER (*s1);
1773 c2 = (gint)(guchar) TOLOWER (*s2);
1780 return (((gint) (guchar) *s1) - ((gint) (guchar) *s2));
1788 * @s2: a string to compare with @s1.
1790 * A case-insensitive string comparison, corresponding to the standard
1791 * strcasecmp() function on platforms which support it.
1793 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1794 * or a positive value if @s1 > @s2.
1796 * Deprecated:2.2: See g_strncasecmp() for a discussion of why this function
1797 * is deprecated and how to replace it.
1800 g_strcasecmp (const gchar *s1,
1803 #ifdef HAVE_STRCASECMP
1804 g_return_val_if_fail (s1 != NULL, 0);
1805 g_return_val_if_fail (s2 != NULL, 0);
1807 return strcasecmp (s1, s2);
1811 g_return_val_if_fail (s1 != NULL, 0);
1812 g_return_val_if_fail (s2 != NULL, 0);
1816 /* According to A. Cox, some platforms have islower's that
1817 * don't work right on non-uppercase
1819 c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
1820 c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
1826 return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
1833 * @s2: a string to compare with @s1.
1834 * @n: the maximum number of characters to compare.
1836 * A case-insensitive string comparison, corresponding to the standard
1837 * strncasecmp() function on platforms which support it.
1838 * It is similar to g_strcasecmp() except it only compares the first @n
1839 * characters of the strings.
1841 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1842 * or a positive value if @s1 > @s2.
1844 * Deprecated:2.2: The problem with g_strncasecmp() is that it does the
1845 * comparison by calling toupper()/tolower(). These functions are
1846 * locale-specific and operate on single bytes. However, it is impossible
1847 * to handle things correctly from an I18N standpoint by operating on
1848 * bytes, since characters may be multibyte. Thus g_strncasecmp() is
1849 * broken if your string is guaranteed to be ASCII, since it's
1850 * locale-sensitive, and it's broken if your string is localized, since
1851 * it doesn't work on many encodings at all, including UTF-8, EUC-JP,
1854 * There are therefore two replacement functions: g_ascii_strncasecmp(),
1855 * which only works on ASCII and is not locale-sensitive, and
1856 * g_utf8_casefold(), which is good for case-insensitive sorting of UTF-8.
1859 g_strncasecmp (const gchar *s1,
1863 #ifdef HAVE_STRNCASECMP
1864 return strncasecmp (s1, s2, n);
1868 g_return_val_if_fail (s1 != NULL, 0);
1869 g_return_val_if_fail (s2 != NULL, 0);
1871 while (n && *s1 && *s2)
1874 /* According to A. Cox, some platforms have islower's that
1875 * don't work right on non-uppercase
1877 c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
1878 c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
1885 return (((gint) (guchar) *s1) - ((gint) (guchar) *s2));
1893 * @string: the string to convert
1894 * @delimiters: a string containing the current delimiters, or %NULL
1895 * to use the standard delimiters defined in #G_STR_DELIMITERS
1896 * @new_delimiter: the new delimiter character
1898 * Converts any delimiter characters in @string to @new_delimiter.
1899 * Any characters in @string which are found in @delimiters are
1900 * changed to the @new_delimiter character. Modifies @string in place,
1901 * and returns @string itself, not a copy. The return value is to
1902 * allow nesting such as
1904 * g_ascii_strup (g_strdelimit (str, "abc", '?'))
1910 g_strdelimit (gchar *string,
1911 const gchar *delimiters,
1916 g_return_val_if_fail (string != NULL, NULL);
1919 delimiters = G_STR_DELIMITERS;
1921 for (c = string; *c; c++)
1923 if (strchr (delimiters, *c))
1932 * @string: a nul-terminated array of bytes
1933 * @valid_chars: bytes permitted in @string
1934 * @substitutor: replacement character for disallowed bytes
1936 * For each character in @string, if the character is not in
1937 * @valid_chars, replaces the character with @substitutor.
1938 * Modifies @string in place, and return @string itself, not
1939 * a copy. The return value is to allow nesting such as
1941 * g_ascii_strup (g_strcanon (str, "abc", '?'))
1947 g_strcanon (gchar *string,
1948 const gchar *valid_chars,
1953 g_return_val_if_fail (string != NULL, NULL);
1954 g_return_val_if_fail (valid_chars != NULL, NULL);
1956 for (c = string; *c; c++)
1958 if (!strchr (valid_chars, *c))
1967 * @source: a string to compress
1969 * Replaces all escaped characters with their one byte equivalent.
1971 * This function does the reverse conversion of g_strescape().
1973 * Returns: a newly-allocated copy of @source with all escaped
1974 * character compressed
1977 g_strcompress (const gchar *source)
1979 const gchar *p = source, *octal;
1980 gchar *dest = g_malloc (strlen (source) + 1);
1991 g_warning ("g_strcompress: trailing \\");
1993 case '0': case '1': case '2': case '3': case '4':
1994 case '5': case '6': case '7':
1997 while ((p < octal + 3) && (*p >= '0') && (*p <= '7'))
1999 *q = (*q * 8) + (*p - '0');
2020 default: /* Also handles \" and \\ */
2037 * @source: a string to escape
2038 * @exceptions: a string of characters not to escape in @source
2040 * Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\'
2041 * and '"' in the string @source by inserting a '\' before
2042 * them. Additionally all characters in the range 0x01-0x1F (everything
2043 * below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are
2044 * replaced with a '\' followed by their octal representation.
2045 * Characters supplied in @exceptions are not escaped.
2047 * g_strcompress() does the reverse conversion.
2049 * Returns: a newly-allocated copy of @source with certain
2050 * characters escaped. See above.
2053 g_strescape (const gchar *source,
2054 const gchar *exceptions)
2061 g_return_val_if_fail (source != NULL, NULL);
2063 p = (guchar *) source;
2064 /* Each source byte needs maximally four destination chars (\777) */
2065 q = dest = g_malloc (strlen (source) * 4 + 1);
2067 memset (excmap, 0, 256);
2070 guchar *e = (guchar *) exceptions;
2116 if ((*p < ' ') || (*p >= 0177))
2119 *q++ = '0' + (((*p) >> 6) & 07);
2120 *q++ = '0' + (((*p) >> 3) & 07);
2121 *q++ = '0' + ((*p) & 07);
2136 * @string: a string to remove the leading whitespace from
2138 * Removes leading whitespace from a string, by moving the rest
2139 * of the characters forward.
2141 * This function doesn't allocate or reallocate any memory;
2142 * it modifies @string in place. The pointer to @string is
2143 * returned to allow the nesting of functions.
2145 * Also see g_strchomp() and g_strstrip().
2150 g_strchug (gchar *string)
2154 g_return_val_if_fail (string != NULL, NULL);
2156 for (start = (guchar*) string; *start && g_ascii_isspace (*start); start++)
2159 g_memmove (string, start, strlen ((gchar *) start) + 1);
2166 * @string: a string to remove the trailing whitespace from
2168 * Removes trailing whitespace from a string.
2170 * This function doesn't allocate or reallocate any memory;
2171 * it modifies @string in place. The pointer to @string is
2172 * returned to allow the nesting of functions.
2174 * Also see g_strchug() and g_strstrip().
2179 g_strchomp (gchar *string)
2183 g_return_val_if_fail (string != NULL, NULL);
2185 len = strlen (string);
2188 if (g_ascii_isspace ((guchar) string[len]))
2199 * @string: a string to split
2200 * @delimiter: a string which specifies the places at which to split
2201 * the string. The delimiter is not included in any of the resulting
2202 * strings, unless @max_tokens is reached.
2203 * @max_tokens: the maximum number of pieces to split @string into.
2204 * If this is less than 1, the string is split completely.
2206 * Splits a string into a maximum of @max_tokens pieces, using the given
2207 * @delimiter. If @max_tokens is reached, the remainder of @string is
2208 * appended to the last token.
2210 * As a special case, the result of splitting the empty string "" is an empty
2211 * vector, not a vector containing a single string. The reason for this
2212 * special case is that being able to represent a empty vector is typically
2213 * more useful than consistent handling of empty elements. If you do need
2214 * to represent empty elements, you'll need to check for the empty string
2215 * before calling g_strsplit().
2217 * Return value: a newly-allocated %NULL-terminated array of strings. Use
2218 * g_strfreev() to free it.
2221 g_strsplit (const gchar *string,
2222 const gchar *delimiter,
2225 GSList *string_list = NULL, *slist;
2226 gchar **str_array, *s;
2228 const gchar *remainder;
2230 g_return_val_if_fail (string != NULL, NULL);
2231 g_return_val_if_fail (delimiter != NULL, NULL);
2232 g_return_val_if_fail (delimiter[0] != '\0', NULL);
2235 max_tokens = G_MAXINT;
2238 s = strstr (remainder, delimiter);
2241 gsize delimiter_len = strlen (delimiter);
2243 while (--max_tokens && s)
2247 len = s - remainder;
2248 string_list = g_slist_prepend (string_list,
2249 g_strndup (remainder, len));
2251 remainder = s + delimiter_len;
2252 s = strstr (remainder, delimiter);
2258 string_list = g_slist_prepend (string_list, g_strdup (remainder));
2261 str_array = g_new (gchar*, n + 1);
2263 str_array[n--] = NULL;
2264 for (slist = string_list; slist; slist = slist->next)
2265 str_array[n--] = slist->data;
2267 g_slist_free (string_list);
2274 * @string: The string to be tokenized
2275 * @delimiters: A nul-terminated string containing bytes that are used
2276 * to split the string.
2277 * @max_tokens: The maximum number of tokens to split @string into.
2278 * If this is less than 1, the string is split completely
2280 * Splits @string into a number of tokens not containing any of the characters
2281 * in @delimiter. A token is the (possibly empty) longest string that does not
2282 * contain any of the characters in @delimiters. If @max_tokens is reached, the
2283 * remainder is appended to the last token.
2285 * For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a
2286 * %NULL-terminated vector containing the three strings "abc", "def",
2289 * The result if g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated
2290 * vector containing the four strings "", "def", "ghi", and "".
2292 * As a special case, the result of splitting the empty string "" is an empty
2293 * vector, not a vector containing a single string. The reason for this
2294 * special case is that being able to represent a empty vector is typically
2295 * more useful than consistent handling of empty elements. If you do need
2296 * to represent empty elements, you'll need to check for the empty string
2297 * before calling g_strsplit_set().
2299 * Note that this function works on bytes not characters, so it can't be used
2300 * to delimit UTF-8 strings for anything but ASCII characters.
2302 * Return value: a newly-allocated %NULL-terminated array of strings. Use
2303 * g_strfreev() to free it.
2308 g_strsplit_set (const gchar *string,
2309 const gchar *delimiters,
2312 gboolean delim_table[256];
2313 GSList *tokens, *list;
2316 const gchar *current;
2320 g_return_val_if_fail (string != NULL, NULL);
2321 g_return_val_if_fail (delimiters != NULL, NULL);
2324 max_tokens = G_MAXINT;
2326 if (*string == '\0')
2328 result = g_new (char *, 1);
2333 memset (delim_table, FALSE, sizeof (delim_table));
2334 for (s = delimiters; *s != '\0'; ++s)
2335 delim_table[*(guchar *)s] = TRUE;
2340 s = current = string;
2343 if (delim_table[*(guchar *)s] && n_tokens + 1 < max_tokens)
2345 token = g_strndup (current, s - current);
2346 tokens = g_slist_prepend (tokens, token);
2355 token = g_strndup (current, s - current);
2356 tokens = g_slist_prepend (tokens, token);
2359 result = g_new (gchar *, n_tokens + 1);
2361 result[n_tokens] = NULL;
2362 for (list = tokens; list != NULL; list = list->next)
2363 result[--n_tokens] = list->data;
2365 g_slist_free (tokens);
2372 * @str_array: a %NULL-terminated array of strings to free
2374 * Frees a %NULL-terminated array of strings, and the array itself.
2375 * If called on a %NULL value, g_strfreev() simply returns.
2378 g_strfreev (gchar **str_array)
2384 for (i = 0; str_array[i] != NULL; i++)
2385 g_free (str_array[i]);
2393 * @str_array: a %NULL-terminated array of strings
2395 * Copies %NULL-terminated array of strings. The copy is a deep copy;
2396 * the new array should be freed by first freeing each string, then
2397 * the array itself. g_strfreev() does this for you. If called
2398 * on a %NULL value, g_strdupv() simply returns %NULL.
2400 * Return value: a new %NULL-terminated array of strings.
2403 g_strdupv (gchar **str_array)
2411 while (str_array[i])
2414 retval = g_new (gchar*, i + 1);
2417 while (str_array[i])
2419 retval[i] = g_strdup (str_array[i]);
2432 * @separator: a string to insert between each of the strings, or %NULL
2433 * @str_array: a %NULL-terminated array of strings to join
2435 * Joins a number of strings together to form one long string, with the
2436 * optional @separator inserted between each of them. The returned string
2437 * should be freed with g_free().
2439 * Returns: a newly-allocated string containing all of the strings joined
2440 * together, with @separator between them
2443 g_strjoinv (const gchar *separator,
2449 g_return_val_if_fail (str_array != NULL, NULL);
2451 if (separator == NULL)
2458 gsize separator_len;
2460 separator_len = strlen (separator);
2461 /* First part, getting length */
2462 len = 1 + strlen (str_array[0]);
2463 for (i = 1; str_array[i] != NULL; i++)
2464 len += strlen (str_array[i]);
2465 len += separator_len * (i - 1);
2467 /* Second part, building string */
2468 string = g_new (gchar, len);
2469 ptr = g_stpcpy (string, *str_array);
2470 for (i = 1; str_array[i] != NULL; i++)
2472 ptr = g_stpcpy (ptr, separator);
2473 ptr = g_stpcpy (ptr, str_array[i]);
2477 string = g_strdup ("");
2484 * @separator: a string to insert between each of the strings, or %NULL
2485 * @...: a %NULL-terminated list of strings to join
2487 * Joins a number of strings together to form one long string, with the
2488 * optional @separator inserted between each of them. The returned string
2489 * should be freed with g_free().
2491 * Returns: a newly-allocated string containing all of the strings joined
2492 * together, with @separator between them
2495 g_strjoin (const gchar *separator,
2501 gsize separator_len;
2504 if (separator == NULL)
2507 separator_len = strlen (separator);
2509 va_start (args, separator);
2511 s = va_arg (args, gchar*);
2515 /* First part, getting length */
2516 len = 1 + strlen (s);
2518 s = va_arg (args, gchar*);
2521 len += separator_len + strlen (s);
2522 s = va_arg (args, gchar*);
2526 /* Second part, building string */
2527 string = g_new (gchar, len);
2529 va_start (args, separator);
2531 s = va_arg (args, gchar*);
2532 ptr = g_stpcpy (string, s);
2534 s = va_arg (args, gchar*);
2537 ptr = g_stpcpy (ptr, separator);
2538 ptr = g_stpcpy (ptr, s);
2539 s = va_arg (args, gchar*);
2543 string = g_strdup ("");
2553 * @haystack: a string
2554 * @haystack_len: the maximum length of @haystack. Note that -1 is
2555 * a valid length, if @haystack is nul-terminated, meaning it will
2556 * search through the whole string.
2557 * @needle: the string to search for
2559 * Searches the string @haystack for the first occurrence
2560 * of the string @needle, limiting the length of the search
2563 * Return value: a pointer to the found occurrence, or
2564 * %NULL if not found.
2567 g_strstr_len (const gchar *haystack,
2568 gssize haystack_len,
2569 const gchar *needle)
2571 g_return_val_if_fail (haystack != NULL, NULL);
2572 g_return_val_if_fail (needle != NULL, NULL);
2574 if (haystack_len < 0)
2575 return strstr (haystack, needle);
2578 const gchar *p = haystack;
2579 gsize needle_len = strlen (needle);
2583 if (needle_len == 0)
2584 return (gchar *)haystack;
2586 if (haystack_len < needle_len)
2589 end = haystack + haystack_len - needle_len;
2591 while (p <= end && *p)
2593 for (i = 0; i < needle_len; i++)
2594 if (p[i] != needle[i])
2609 * @haystack: a nul-terminated string
2610 * @needle: the nul-terminated string to search for
2612 * Searches the string @haystack for the last occurrence
2613 * of the string @needle.
2615 * Return value: a pointer to the found occurrence, or
2616 * %NULL if not found.
2619 g_strrstr (const gchar *haystack,
2620 const gchar *needle)
2627 g_return_val_if_fail (haystack != NULL, NULL);
2628 g_return_val_if_fail (needle != NULL, NULL);
2630 needle_len = strlen (needle);
2631 haystack_len = strlen (haystack);
2633 if (needle_len == 0)
2634 return (gchar *)haystack;
2636 if (haystack_len < needle_len)
2639 p = haystack + haystack_len - needle_len;
2641 while (p >= haystack)
2643 for (i = 0; i < needle_len; i++)
2644 if (p[i] != needle[i])
2658 * @haystack: a nul-terminated string
2659 * @haystack_len: the maximum length of @haystack
2660 * @needle: the nul-terminated string to search for
2662 * Searches the string @haystack for the last occurrence
2663 * of the string @needle, limiting the length of the search
2666 * Return value: a pointer to the found occurrence, or
2667 * %NULL if not found.
2670 g_strrstr_len (const gchar *haystack,
2671 gssize haystack_len,
2672 const gchar *needle)
2674 g_return_val_if_fail (haystack != NULL, NULL);
2675 g_return_val_if_fail (needle != NULL, NULL);
2677 if (haystack_len < 0)
2678 return g_strrstr (haystack, needle);
2681 gsize needle_len = strlen (needle);
2682 const gchar *haystack_max = haystack + haystack_len;
2683 const gchar *p = haystack;
2686 while (p < haystack_max && *p)
2689 if (p < haystack + needle_len)
2694 while (p >= haystack)
2696 for (i = 0; i < needle_len; i++)
2697 if (p[i] != needle[i])
2713 * @str: a nul-terminated string
2714 * @suffix: the nul-terminated suffix to look for
2716 * Looks whether the string @str ends with @suffix.
2718 * Return value: %TRUE if @str end with @suffix, %FALSE otherwise.
2723 g_str_has_suffix (const gchar *str,
2724 const gchar *suffix)
2729 g_return_val_if_fail (str != NULL, FALSE);
2730 g_return_val_if_fail (suffix != NULL, FALSE);
2732 str_len = strlen (str);
2733 suffix_len = strlen (suffix);
2735 if (str_len < suffix_len)
2738 return strcmp (str + str_len - suffix_len, suffix) == 0;
2743 * @str: a nul-terminated string
2744 * @prefix: the nul-terminated prefix to look for
2746 * Looks whether the string @str begins with @prefix.
2748 * Return value: %TRUE if @str begins with @prefix, %FALSE otherwise.
2753 g_str_has_prefix (const gchar *str,
2754 const gchar *prefix)
2759 g_return_val_if_fail (str != NULL, FALSE);
2760 g_return_val_if_fail (prefix != NULL, FALSE);
2762 str_len = strlen (str);
2763 prefix_len = strlen (prefix);
2765 if (str_len < prefix_len)
2768 return strncmp (str, prefix, prefix_len) == 0;
2773 * @str_array: a %NULL-terminated array of strings
2775 * Returns the length of the given %NULL-terminated
2776 * string array @str_array.
2778 * Return value: length of @str_array.
2783 g_strv_length (gchar **str_array)
2787 g_return_val_if_fail (str_array != NULL, 0);
2789 while (str_array[i])