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/.
33 #define _GNU_SOURCE /* For stpcpy */
41 #include <ctype.h> /* For tolower() */
42 #if !defined (HAVE_STRSIGNAL) || !defined(NO_SYS_SIGLIST_DECL)
48 #include "gprintfint.h"
57 /* do not include <unistd.h> in this place since it
58 * interferes with g_strsignal() on some OSes
61 static const guint16 ascii_table_data[256] = {
62 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
63 0x004, 0x104, 0x104, 0x004, 0x104, 0x104, 0x004, 0x004,
64 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
65 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004, 0x004,
66 0x140, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
67 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
68 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459, 0x459,
69 0x459, 0x459, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
70 0x0d0, 0x653, 0x653, 0x653, 0x653, 0x653, 0x653, 0x253,
71 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
72 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253, 0x253,
73 0x253, 0x253, 0x253, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x0d0,
74 0x0d0, 0x473, 0x473, 0x473, 0x473, 0x473, 0x473, 0x073,
75 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
76 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073, 0x073,
77 0x073, 0x073, 0x073, 0x0d0, 0x0d0, 0x0d0, 0x0d0, 0x004
78 /* the upper 128 are all zeroes */
81 const guint16 * const g_ascii_table = ascii_table_data;
84 g_strdup (const gchar *str)
91 length = strlen (str) + 1;
92 new_str = g_new (char, length);
93 memcpy (new_str, str, length);
102 g_memdup (gconstpointer mem,
109 new_mem = g_malloc (byte_size);
110 memcpy (new_mem, mem, byte_size);
120 * @str: the string to duplicate
121 * @n: the maximum number of bytes to copy from @str
123 * Duplicates the first @n bytes of a string, returning a newly-allocated
124 * buffer @n + 1 bytes long which will always be nul-terminated.
125 * If @str is less than @n bytes long the buffer is padded with nuls.
126 * If @str is %NULL it returns %NULL.
127 * The returned value should be freed when no longer needed.
130 * To copy a number of characters from a UTF-8 encoded string, use
131 * g_utf8_strncpy() instead.
134 * Returns: a newly-allocated buffer containing the first @n bytes
135 * of @str, nul-terminated
138 g_strndup (const gchar *str,
145 new_str = g_new (gchar, n + 1);
146 strncpy (new_str, str, n);
157 * @length: the length of the new string
158 * @fill_char: the byte to fill the string with
160 * Creates a new string @length bytes long filled with @fill_char.
161 * The returned string should be freed when no longer needed.
163 * Returns: a newly-allocated string filled the @fill_char
166 g_strnfill (gsize length,
171 str = g_new (gchar, length + 1);
172 memset (str, (guchar)fill_char, length);
180 * @dest: destination buffer.
181 * @src: source string.
183 * Copies a nul-terminated string into the dest buffer, include the
184 * trailing nul, and return a pointer to the trailing nul byte.
185 * This is useful for concatenating multiple strings together
186 * without having to repeatedly scan for the end.
188 * Return value: a pointer to trailing nul byte.
191 g_stpcpy (gchar *dest,
195 g_return_val_if_fail (dest != NULL, NULL);
196 g_return_val_if_fail (src != NULL, NULL);
197 return stpcpy (dest, src);
199 register gchar *d = dest;
200 register const gchar *s = src;
202 g_return_val_if_fail (dest != NULL, NULL);
203 g_return_val_if_fail (src != NULL, NULL);
206 while (*s++ != '\0');
213 g_strdup_vprintf (const gchar *format,
216 gchar *string = NULL;
218 g_vasprintf (&string, format, args);
224 g_strdup_printf (const gchar *format,
230 va_start (args, format);
231 buffer = g_strdup_vprintf (format, args);
238 g_strconcat (const gchar *string1, ...)
249 l = 1 + strlen (string1);
250 va_start (args, string1);
251 s = va_arg (args, gchar*);
255 s = va_arg (args, gchar*);
259 concat = g_new (gchar, l);
262 ptr = g_stpcpy (ptr, string1);
263 va_start (args, string1);
264 s = va_arg (args, gchar*);
267 ptr = g_stpcpy (ptr, s);
268 s = va_arg (args, gchar*);
277 * @nptr: the string to convert to a numeric value.
278 * @endptr: if non-%NULL, it returns the character after
279 * the last character used in the conversion.
281 * Converts a string to a #gdouble value.
282 * It calls the standard strtod() function to handle the conversion, but
283 * if the string is not completely converted it attempts the conversion
284 * again with g_ascii_strtod(), and returns the best match.
286 * This function should seldomly be used. The normal situation when reading
287 * numbers not for human consumption is to use g_ascii_strtod(). Only when
288 * you know that you must expect both locale formatted and C formatted numbers
289 * should you use this. Make sure that you don't pass strings such as comma
290 * separated lists of values, since the commas may be interpreted as a decimal
291 * point in some locales, causing unexpected results.
293 * Return value: the #gdouble value.
296 g_strtod (const gchar *nptr,
304 g_return_val_if_fail (nptr != NULL, 0);
309 val_1 = strtod (nptr, &fail_pos_1);
311 if (fail_pos_1 && fail_pos_1[0] != 0)
312 val_2 = g_ascii_strtod (nptr, &fail_pos_2);
314 if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)
317 *endptr = fail_pos_1;
323 *endptr = fail_pos_2;
330 * @nptr: the string to convert to a numeric value.
331 * @endptr: if non-%NULL, it returns the character after
332 * the last character used in the conversion.
334 * Converts a string to a #gdouble value.
336 * This function behaves like the standard strtod() function
337 * does in the C locale. It does this without actually changing
338 * the current locale, since that would not be thread-safe.
339 * A limitation of the implementation is that this function
340 * will still accept localized versions of infinities and NANs.
342 * This function is typically used when reading configuration
343 * files or other non-user input that should be locale independent.
344 * To handle input from the user you should normally use the
345 * locale-sensitive system strtod() function.
347 * To convert from a #gdouble to a string in a locale-insensitive
348 * way, use g_ascii_dtostr().
350 * If the correct value would cause overflow, plus or minus %HUGE_VAL
351 * is returned (according to the sign of the value), and %ERANGE is
352 * stored in %errno. If the correct value would cause underflow,
353 * zero is returned and %ERANGE is stored in %errno.
355 * This function resets %errno before calling strtod() so that
356 * you can reliably detect overflow and underflow.
358 * Return value: the #gdouble value.
361 g_ascii_strtod (const gchar *nptr,
366 struct lconv *locale_data;
367 const char *decimal_point;
368 int decimal_point_len;
369 const char *p, *decimal_point_pos;
370 const char *end = NULL; /* Silence gcc */
373 g_return_val_if_fail (nptr != NULL, 0);
377 locale_data = localeconv ();
378 decimal_point = locale_data->decimal_point;
379 decimal_point_len = strlen (decimal_point);
381 g_assert (decimal_point_len != 0);
383 decimal_point_pos = NULL;
386 if (decimal_point[0] != '.' ||
387 decimal_point[1] != 0)
390 /* Skip leading space */
391 while (g_ascii_isspace (*p))
394 /* Skip leading optional sign */
395 if (*p == '+' || *p == '-')
399 (p[1] == 'x' || p[1] == 'X'))
402 /* HEX - find the (optional) decimal point */
404 while (g_ascii_isxdigit (*p))
408 decimal_point_pos = p++;
410 while (g_ascii_isxdigit (*p))
413 if (*p == 'p' || *p == 'P')
415 if (*p == '+' || *p == '-')
417 while (g_ascii_isdigit (*p))
422 else if (g_ascii_isdigit (*p) || *p == '.')
424 while (g_ascii_isdigit (*p))
428 decimal_point_pos = p++;
430 while (g_ascii_isdigit (*p))
433 if (*p == 'e' || *p == 'E')
435 if (*p == '+' || *p == '-')
437 while (g_ascii_isdigit (*p))
442 /* For the other cases, we need not convert the decimal point */
445 if (decimal_point_pos)
449 /* We need to convert the '.' to the locale specific decimal point */
450 copy = g_malloc (end - nptr + 1 + decimal_point_len);
453 memcpy (c, nptr, decimal_point_pos - nptr);
454 c += decimal_point_pos - nptr;
455 memcpy (c, decimal_point, decimal_point_len);
456 c += decimal_point_len;
457 memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1));
458 c += end - (decimal_point_pos + 1);
462 val = strtod (copy, &fail_pos);
463 strtod_errno = errno;
467 if (fail_pos - copy > decimal_point_pos - nptr)
468 fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);
470 fail_pos = (char *)nptr + (fail_pos - copy);
480 copy = g_malloc (end - (char *)nptr + 1);
481 memcpy (copy, nptr, end - nptr);
482 *(copy + (end - (char *)nptr)) = 0;
485 val = strtod (copy, &fail_pos);
486 strtod_errno = errno;
490 fail_pos = (char *)nptr + (fail_pos - copy);
498 val = strtod (nptr, &fail_pos);
499 strtod_errno = errno;
505 errno = strtod_errno;
513 * @buffer: A buffer to place the resulting string in
514 * @buf_len: The length of the buffer.
515 * @d: The #gdouble to convert
517 * Converts a #gdouble to a string, using the '.' as
520 * This functions generates enough precision that converting
521 * the string back using g_ascii_strtod() gives the same machine-number
522 * (on machines with IEEE compatible 64bit doubles). It is
523 * guaranteed that the size of the resulting string will never
524 * be larger than @G_ASCII_DTOSTR_BUF_SIZE bytes.
526 * Return value: The pointer to the buffer with the converted string.
529 g_ascii_dtostr (gchar *buffer,
533 return g_ascii_formatd (buffer, buf_len, "%.17g", d);
538 * @buffer: A buffer to place the resulting string in
539 * @buf_len: The length of the buffer.
540 * @format: The printf()-style format to use for the
541 * code to use for converting.
542 * @d: The #gdouble to convert
544 * Converts a #gdouble to a string, using the '.' as
545 * decimal point. To format the number you pass in
546 * a printf()-style format string. Allowed conversion
547 * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
549 * If you just want to want to serialize the value into a
550 * string, use g_ascii_dtostr().
552 * Return value: The pointer to the buffer with the converted string.
555 g_ascii_formatd (gchar *buffer,
560 struct lconv *locale_data;
561 const char *decimal_point;
562 int decimal_point_len;
567 g_return_val_if_fail (buffer != NULL, NULL);
568 g_return_val_if_fail (format[0] == '%', NULL);
569 g_return_val_if_fail (strpbrk (format + 1, "'l%") == NULL, NULL);
571 format_char = format[strlen (format) - 1];
573 g_return_val_if_fail (format_char == 'e' || format_char == 'E' ||
574 format_char == 'f' || format_char == 'F' ||
575 format_char == 'g' || format_char == 'G',
578 if (format[0] != '%')
581 if (strpbrk (format + 1, "'l%"))
584 if (!(format_char == 'e' || format_char == 'E' ||
585 format_char == 'f' || format_char == 'F' ||
586 format_char == 'g' || format_char == 'G'))
590 _g_snprintf (buffer, buf_len, format, d);
592 locale_data = localeconv ();
593 decimal_point = locale_data->decimal_point;
594 decimal_point_len = strlen (decimal_point);
596 g_assert (decimal_point_len != 0);
598 if (decimal_point[0] != '.' ||
599 decimal_point[1] != 0)
603 while (g_ascii_isspace (*p))
606 if (*p == '+' || *p == '-')
609 while (isdigit ((guchar)*p))
612 if (strncmp (p, decimal_point, decimal_point_len) == 0)
616 if (decimal_point_len > 1)
618 rest_len = strlen (p + (decimal_point_len-1));
619 memmove (p, p + (decimal_point_len-1), rest_len);
629 g_parse_long_long (const gchar *nptr,
630 const gchar **endptr,
634 /* this code is based on on the strtol(3) code from GNU libc released under
635 * the GNU Lesser General Public License.
637 * Copyright (C) 1991,92,94,95,96,97,98,99,2000,01,02
638 * Free Software Foundation, Inc.
640 #define ISSPACE(c) ((c) == ' ' || (c) == '\f' || (c) == '\n' || \
641 (c) == '\r' || (c) == '\t' || (c) == '\v')
642 #define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
643 #define ISLOWER(c) ((c) >= 'a' && (c) <= 'z')
644 #define ISALPHA(c) (ISUPPER (c) || ISLOWER (c))
645 #define TOUPPER(c) (ISLOWER (c) ? (c) - 'a' + 'A' : (c))
646 #define TOLOWER(c) (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
651 const gchar *s, *save;
654 g_return_val_if_fail (nptr != NULL, 0);
657 if (base == 1 || base > 36)
667 /* Skip white space. */
671 if (G_UNLIKELY (!*s))
674 /* Check for a sign. */
683 /* Recognize number prefix and if BASE is zero, figure it out ourselves. */
686 if ((base == 0 || base == 16) && TOUPPER (s[1]) == 'X')
697 /* Save the pointer so we can check later if anything happened. */
699 cutoff = G_MAXUINT64 / base;
700 cutlim = G_MAXUINT64 % base;
707 if (c >= '0' && c <= '9')
709 else if (ISALPHA (c))
710 c = TOUPPER (c) - 'A' + 10;
715 /* Check for overflow. */
716 if (ui64 > cutoff || (ui64 == cutoff && c > cutlim))
725 /* Check if anything actually happened. */
729 /* Store in ENDPTR the address of one character
730 past the last character we converted. */
734 if (G_UNLIKELY (overflow))
743 /* We must handle a special case here: the base is 0 or 16 and the
744 first two characters are '0' and 'x', but the rest are no
745 hexadecimal digits. This is no error case. We return 0 and
746 ENDPTR points to the `x`. */
749 if (save - nptr >= 2 && TOUPPER (save[-1]) == 'X'
753 /* There was no number to convert. */
761 * @nptr: the string to convert to a numeric value.
762 * @endptr: if non-%NULL, it returns the character after
763 * the last character used in the conversion.
764 * @base: to be used for the conversion, 2..36 or 0
766 * Converts a string to a #guint64 value.
767 * This function behaves like the standard strtoull() function
768 * does in the C locale. It does this without actually
769 * changing the current locale, since that would not be
772 * This function is typically used when reading configuration
773 * files or other non-user input that should be locale independent.
774 * To handle input from the user you should normally use the
775 * locale-sensitive system strtoull() function.
777 * If the correct value would cause overflow, %G_MAXUINT64
778 * is returned, and %ERANGE is stored in %errno. If the base is
779 * outside the valid range, zero is returned, and %EINVAL is stored
780 * in %errno. If the string conversion fails, zero is returned, and
781 * @endptr returns @nptr (if @endptr is non-%NULL).
783 * Return value: the #guint64 value or zero on error.
788 g_ascii_strtoull (const gchar *nptr,
795 result = g_parse_long_long (nptr, (const gchar **) endptr, base, &negative);
797 /* Return the result of the appropriate sign. */
798 return negative ? -result : result;
803 * @nptr: the string to convert to a numeric value.
804 * @endptr: if non-%NULL, it returns the character after
805 * the last character used in the conversion.
806 * @base: to be used for the conversion, 2..36 or 0
808 * Converts a string to a #gint64 value.
809 * This function behaves like the standard strtoll() function
810 * does in the C locale. It does this without actually
811 * changing the current locale, since that would not be
814 * This function is typically used when reading configuration
815 * files or other non-user input that should be locale independent.
816 * To handle input from the user you should normally use the
817 * locale-sensitive system strtoll() function.
819 * If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64
820 * is returned, and %ERANGE is stored in %errno. If the base is
821 * outside the valid range, zero is returned, and %EINVAL is stored
822 * in %errno. If the string conversion fails, zero is returned, and
823 * @endptr returns @nptr (if @endptr is non-%NULL).
825 * Return value: the #gint64 value or zero on error.
830 g_ascii_strtoll (const gchar *nptr,
837 result = g_parse_long_long (nptr, (const gchar **) endptr, base, &negative);
839 if (negative && result > (guint64) G_MININT64)
844 else if (!negative && result > (guint64) G_MAXINT64)
850 return - (gint64) result;
852 return (gint64) result;
855 G_CONST_RETURN gchar*
856 g_strerror (gint errnum)
858 static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
860 int saved_errno = errno;
863 const char *msg_locale;
865 msg_locale = strerror (errnum);
866 if (g_get_charset (NULL))
873 gchar *msg_utf8 = g_locale_to_utf8 (msg_locale, -1, NULL, NULL, NULL);
876 /* Stick in the quark table so that we can return a static result
878 GQuark msg_quark = g_quark_from_string (msg_utf8);
881 msg_utf8 = (gchar *) g_quark_to_string (msg_quark);
890 case E2BIG: return "argument list too long";
893 case EACCES: return "permission denied";
896 case EADDRINUSE: return "address already in use";
899 case EADDRNOTAVAIL: return "can't assign requested address";
902 case EADV: return "advertise error";
905 case EAFNOSUPPORT: return "address family not supported by protocol family";
908 case EAGAIN: return "try again";
911 case EALIGN: return "EALIGN";
914 case EALREADY: return "operation already in progress";
917 case EBADE: return "bad exchange descriptor";
920 case EBADF: return "bad file number";
923 case EBADFD: return "file descriptor in bad state";
926 case EBADMSG: return "not a data message";
929 case EBADR: return "bad request descriptor";
932 case EBADRPC: return "RPC structure is bad";
935 case EBADRQC: return "bad request code";
938 case EBADSLT: return "invalid slot";
941 case EBFONT: return "bad font file format";
944 case EBUSY: return "mount device busy";
947 case ECHILD: return "no children";
950 case ECHRNG: return "channel number out of range";
953 case ECOMM: return "communication error on send";
956 case ECONNABORTED: return "software caused connection abort";
959 case ECONNREFUSED: return "connection refused";
962 case ECONNRESET: return "connection reset by peer";
964 #if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))
965 case EDEADLK: return "resource deadlock avoided";
968 case EDEADLOCK: return "resource deadlock avoided";
971 case EDESTADDRREQ: return "destination address required";
974 case EDIRTY: return "mounting a dirty fs w/o force";
977 case EDOM: return "math argument out of range";
980 case EDOTDOT: return "cross mount point";
983 case EDQUOT: return "disk quota exceeded";
986 case EDUPPKG: return "duplicate package name";
989 case EEXIST: return "file already exists";
992 case EFAULT: return "bad address in system call argument";
995 case EFBIG: return "file too large";
998 case EHOSTDOWN: return "host is down";
1001 case EHOSTUNREACH: return "host is unreachable";
1004 case EIDRM: return "identifier removed";
1007 case EINIT: return "initialization error";
1010 case EINPROGRESS: return "operation now in progress";
1013 case EINTR: return "interrupted system call";
1016 case EINVAL: return "invalid argument";
1019 case EIO: return "I/O error";
1022 case EISCONN: return "socket is already connected";
1025 case EISDIR: return "is a directory";
1028 case EISNAM: return "is a name file";
1031 case ELBIN: return "ELBIN";
1034 case EL2HLT: return "level 2 halted";
1037 case EL2NSYNC: return "level 2 not synchronized";
1040 case EL3HLT: return "level 3 halted";
1043 case EL3RST: return "level 3 reset";
1046 case ELIBACC: return "can not access a needed shared library";
1049 case ELIBBAD: return "accessing a corrupted shared library";
1052 case ELIBEXEC: return "can not exec a shared library directly";
1055 case ELIBMAX: return "attempting to link in more shared libraries than system limit";
1058 case ELIBSCN: return ".lib section in a.out corrupted";
1061 case ELNRNG: return "link number out of range";
1064 case ELOOP: return "too many levels of symbolic links";
1067 case EMFILE: return "too many open files";
1070 case EMLINK: return "too many links";
1073 case EMSGSIZE: return "message too long";
1076 case EMULTIHOP: return "multihop attempted";
1079 case ENAMETOOLONG: return "file name too long";
1082 case ENAVAIL: return "not available";
1085 case ENET: return "ENET";
1088 case ENETDOWN: return "network is down";
1091 case ENETRESET: return "network dropped connection on reset";
1094 case ENETUNREACH: return "network is unreachable";
1097 case ENFILE: return "file table overflow";
1100 case ENOANO: return "anode table overflow";
1102 #if defined(ENOBUFS) && (!defined(ENOSR) || (ENOBUFS != ENOSR))
1103 case ENOBUFS: return "no buffer space available";
1106 case ENOCSI: return "no CSI structure available";
1109 case ENODATA: return "no data available";
1112 case ENODEV: return "no such device";
1115 case ENOENT: return "no such file or directory";
1118 case ENOEXEC: return "exec format error";
1121 case ENOLCK: return "no locks available";
1124 case ENOLINK: return "link has be severed";
1127 case ENOMEM: return "not enough memory";
1130 case ENOMSG: return "no message of desired type";
1133 case ENONET: return "machine is not on the network";
1136 case ENOPKG: return "package not installed";
1139 case ENOPROTOOPT: return "bad proocol option";
1142 case ENOSPC: return "no space left on device";
1145 case ENOSR: return "out of stream resources";
1148 case ENOSTR: return "not a stream device";
1151 case ENOSYM: return "unresolved symbol name";
1154 case ENOSYS: return "function not implemented";
1157 case ENOTBLK: return "block device required";
1160 case ENOTCONN: return "socket is not connected";
1163 case ENOTDIR: return "not a directory";
1166 case ENOTEMPTY: return "directory not empty";
1169 case ENOTNAM: return "not a name file";
1172 case ENOTSOCK: return "socket operation on non-socket";
1175 case ENOTTY: return "inappropriate device for ioctl";
1178 case ENOTUNIQ: return "name not unique on network";
1181 case ENXIO: return "no such device or address";
1184 case EOPNOTSUPP: return "operation not supported on socket";
1187 case EPERM: return "not owner";
1190 case EPFNOSUPPORT: return "protocol family not supported";
1193 case EPIPE: return "broken pipe";
1196 case EPROCLIM: return "too many processes";
1199 case EPROCUNAVAIL: return "bad procedure for program";
1201 #ifdef EPROGMISMATCH
1202 case EPROGMISMATCH: return "program version wrong";
1205 case EPROGUNAVAIL: return "RPC program not available";
1208 case EPROTO: return "protocol error";
1210 #ifdef EPROTONOSUPPORT
1211 case EPROTONOSUPPORT: return "protocol not suppored";
1214 case EPROTOTYPE: return "protocol wrong type for socket";
1217 case ERANGE: return "math result unrepresentable";
1219 #if defined(EREFUSED) && (!defined(ECONNREFUSED) || (EREFUSED != ECONNREFUSED))
1220 case EREFUSED: return "EREFUSED";
1223 case EREMCHG: return "remote address changed";
1226 case EREMDEV: return "remote device";
1229 case EREMOTE: return "pathname hit remote file system";
1232 case EREMOTEIO: return "remote i/o error";
1234 #ifdef EREMOTERELEASE
1235 case EREMOTERELEASE: return "EREMOTERELEASE";
1238 case EROFS: return "read-only file system";
1241 case ERPCMISMATCH: return "RPC version is wrong";
1244 case ERREMOTE: return "object is remote";
1247 case ESHUTDOWN: return "can't send afer socket shutdown";
1249 #ifdef ESOCKTNOSUPPORT
1250 case ESOCKTNOSUPPORT: return "socket type not supported";
1253 case ESPIPE: return "invalid seek";
1256 case ESRCH: return "no such process";
1259 case ESRMNT: return "srmount error";
1262 case ESTALE: return "stale remote file handle";
1265 case ESUCCESS: return "Error 0";
1268 case ETIME: return "timer expired";
1271 case ETIMEDOUT: return "connection timed out";
1274 case ETOOMANYREFS: return "too many references: can't splice";
1277 case ETXTBSY: return "text file or pseudo-device busy";
1280 case EUCLEAN: return "structure needs cleaning";
1283 case EUNATCH: return "protocol driver not attached";
1286 case EUSERS: return "too many users";
1289 case EVERSION: return "version mismatch";
1291 #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
1292 case EWOULDBLOCK: return "operation would block";
1295 case EXDEV: return "cross-domain link";
1298 case EXFULL: return "message tables full";
1301 #else /* NO_SYS_ERRLIST */
1302 extern int sys_nerr;
1303 extern char *sys_errlist[];
1305 if ((errnum > 0) && (errnum <= sys_nerr))
1306 return sys_errlist [errnum];
1307 #endif /* NO_SYS_ERRLIST */
1309 msg = g_static_private_get (&msg_private);
1312 msg = g_new (gchar, 64);
1313 g_static_private_set (&msg_private, msg, g_free);
1316 _g_sprintf (msg, "unknown error (%d)", errnum);
1318 errno = saved_errno;
1322 G_CONST_RETURN gchar*
1323 g_strsignal (gint signum)
1325 static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
1328 #ifdef HAVE_STRSIGNAL
1329 const char *msg_locale;
1331 #if defined(G_OS_BEOS) || defined(G_WITH_CYGWIN)
1332 extern const char *strsignal(int);
1334 /* this is declared differently (const) in string.h on BeOS */
1335 extern char *strsignal (int sig);
1336 #endif /* !G_OS_BEOS && !G_WITH_CYGWIN */
1337 msg_locale = strsignal (signum);
1338 if (g_get_charset (NULL))
1342 gchar *msg_utf8 = g_locale_to_utf8 (msg_locale, -1, NULL, NULL, NULL);
1345 /* Stick in the quark table so that we can return a static result
1347 GQuark msg_quark = g_quark_from_string (msg_utf8);
1350 return g_quark_to_string (msg_quark);
1353 #elif NO_SYS_SIGLIST
1357 case SIGHUP: return "Hangup";
1360 case SIGINT: return "Interrupt";
1363 case SIGQUIT: return "Quit";
1366 case SIGILL: return "Illegal instruction";
1369 case SIGTRAP: return "Trace/breakpoint trap";
1372 case SIGABRT: return "IOT trap/Abort";
1375 case SIGBUS: return "Bus error";
1378 case SIGFPE: return "Floating point exception";
1381 case SIGKILL: return "Killed";
1384 case SIGUSR1: return "User defined signal 1";
1387 case SIGSEGV: return "Segmentation fault";
1390 case SIGUSR2: return "User defined signal 2";
1393 case SIGPIPE: return "Broken pipe";
1396 case SIGALRM: return "Alarm clock";
1399 case SIGTERM: return "Terminated";
1402 case SIGSTKFLT: return "Stack fault";
1405 case SIGCHLD: return "Child exited";
1408 case SIGCONT: return "Continued";
1411 case SIGSTOP: return "Stopped (signal)";
1414 case SIGTSTP: return "Stopped";
1417 case SIGTTIN: return "Stopped (tty input)";
1420 case SIGTTOU: return "Stopped (tty output)";
1423 case SIGURG: return "Urgent condition";
1426 case SIGXCPU: return "CPU time limit exceeded";
1429 case SIGXFSZ: return "File size limit exceeded";
1432 case SIGVTALRM: return "Virtual time alarm";
1435 case SIGPROF: return "Profile signal";
1438 case SIGWINCH: return "Window size changed";
1441 case SIGIO: return "Possible I/O";
1444 case SIGPWR: return "Power failure";
1447 case SIGUNUSED: return "Unused signal";
1450 #else /* NO_SYS_SIGLIST */
1452 #ifdef NO_SYS_SIGLIST_DECL
1453 extern char *sys_siglist[]; /*(see Tue Jan 19 00:44:24 1999 in changelog)*/
1456 return (char*) /* this function should return const --josh */ sys_siglist [signum];
1457 #endif /* NO_SYS_SIGLIST */
1459 msg = g_static_private_get (&msg_private);
1462 msg = g_new (gchar, 64);
1463 g_static_private_set (&msg_private, msg, g_free);
1466 _g_sprintf (msg, "unknown signal (%d)", signum);
1471 /* Functions g_strlcpy and g_strlcat were originally developed by
1472 * Todd C. Miller <Todd.Miller@courtesan.com> to simplify writing secure code.
1473 * See ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/strlcpy.3
1474 * for more information.
1478 /* Use the native ones, if available; they might be implemented in assembly */
1480 g_strlcpy (gchar *dest,
1484 g_return_val_if_fail (dest != NULL, 0);
1485 g_return_val_if_fail (src != NULL, 0);
1487 return strlcpy (dest, src, dest_size);
1491 g_strlcat (gchar *dest,
1495 g_return_val_if_fail (dest != NULL, 0);
1496 g_return_val_if_fail (src != NULL, 0);
1498 return strlcat (dest, src, dest_size);
1501 #else /* ! HAVE_STRLCPY */
1504 * Copy string src to buffer dest (of buffer size dest_size). At most
1505 * dest_size-1 characters will be copied. Always NUL terminates
1506 * (unless dest_size == 0). This function does NOT allocate memory.
1507 * Unlike strncpy, this function doesn't pad dest (so it's often faster).
1508 * Returns size of attempted result, strlen(src),
1509 * so if retval >= dest_size, truncation occurred.
1512 g_strlcpy (gchar *dest,
1516 register gchar *d = dest;
1517 register const gchar *s = src;
1518 register gsize n = dest_size;
1520 g_return_val_if_fail (dest != NULL, 0);
1521 g_return_val_if_fail (src != NULL, 0);
1523 /* Copy as many bytes as will fit */
1524 if (n != 0 && --n != 0)
1527 register gchar c = *s++;
1535 /* If not enough room in dest, add NUL and traverse rest of src */
1544 return s - src - 1; /* count does not include NUL */
1549 * Appends string src to buffer dest (of buffer size dest_size).
1550 * At most dest_size-1 characters will be copied.
1551 * Unlike strncat, dest_size is the full size of dest, not the space left over.
1552 * This function does NOT allocate memory.
1553 * This always NUL terminates (unless siz == 0 or there were no NUL characters
1554 * in the dest_size characters of dest to start with).
1555 * Returns size of attempted result, which is
1556 * MIN (dest_size, strlen (original dest)) + strlen (src),
1557 * so if retval >= dest_size, truncation occurred.
1560 g_strlcat (gchar *dest,
1564 register gchar *d = dest;
1565 register const gchar *s = src;
1566 register gsize bytes_left = dest_size;
1567 gsize dlength; /* Logically, MIN (strlen (d), dest_size) */
1569 g_return_val_if_fail (dest != NULL, 0);
1570 g_return_val_if_fail (src != NULL, 0);
1572 /* Find the end of dst and adjust bytes left but don't go past end */
1573 while (*d != 0 && bytes_left-- != 0)
1576 bytes_left = dest_size - dlength;
1578 if (bytes_left == 0)
1579 return dlength + strlen (s);
1583 if (bytes_left != 1)
1592 return dlength + (s - src); /* count does not include NUL */
1594 #endif /* ! HAVE_STRLCPY */
1599 * @len: length of @str in bytes, or -1 if @str is nul-terminated.
1601 * Converts all upper case ASCII letters to lower case ASCII letters.
1603 * Return value: a newly-allocated string, with all the upper case
1604 * characters in @str converted to lower case, with
1605 * semantics that exactly match g_ascii_tolower(). (Note
1606 * that this is unlike the old g_strdown(), which modified
1607 * the string in place.)
1610 g_ascii_strdown (const gchar *str,
1615 g_return_val_if_fail (str != NULL, NULL);
1620 result = g_strndup (str, len);
1621 for (s = result; *s; s++)
1622 *s = g_ascii_tolower (*s);
1630 * @len: length of @str in bytes, or -1 if @str is nul-terminated.
1632 * Converts all lower case ASCII letters to upper case ASCII letters.
1634 * Return value: a newly allocated string, with all the lower case
1635 * characters in @str converted to upper case, with
1636 * semantics that exactly match g_ascii_toupper(). (Note
1637 * that this is unlike the old g_strup(), which modified
1638 * the string in place.)
1641 g_ascii_strup (const gchar *str,
1646 g_return_val_if_fail (str != NULL, NULL);
1651 result = g_strndup (str, len);
1652 for (s = result; *s; s++)
1653 *s = g_ascii_toupper (*s);
1660 * @string: the string to convert.
1662 * Converts a string to lower case.
1664 * Return value: the string
1666 * Deprecated:2.2: This function is totally broken for the reasons discussed
1667 * in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown()
1671 g_strdown (gchar *string)
1675 g_return_val_if_fail (string != NULL, NULL);
1677 s = (guchar *) string;
1686 return (gchar *) string;
1691 * @string: the string to convert.
1693 * Converts a string to upper case.
1695 * Return value: the string
1697 * Deprecated:2.2: This function is totally broken for the reasons discussed
1698 * in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.
1701 g_strup (gchar *string)
1705 g_return_val_if_fail (string != NULL, NULL);
1707 s = (guchar *) string;
1716 return (gchar *) string;
1720 g_strreverse (gchar *string)
1722 g_return_val_if_fail (string != NULL, NULL);
1726 register gchar *h, *t;
1729 t = string + strlen (string) - 1;
1748 * @c: any character.
1750 * Convert a character to ASCII lower case.
1752 * Unlike the standard C library tolower() function, this only
1753 * recognizes standard ASCII letters and ignores the locale, returning
1754 * all non-ASCII characters unchanged, even if they are lower case
1755 * letters in a particular character set. Also unlike the standard
1756 * library function, this takes and returns a char, not an int, so
1757 * don't call it on %EOF but no need to worry about casting to #guchar
1758 * before passing a possibly non-ASCII character in.
1760 * Return value: the result of converting @c to lower case.
1761 * If @c is not an ASCII upper case letter,
1762 * @c is returned unchanged.
1765 g_ascii_tolower (gchar c)
1767 return g_ascii_isupper (c) ? c - 'A' + 'a' : c;
1772 * @c: any character.
1774 * Convert a character to ASCII upper case.
1776 * Unlike the standard C library toupper() function, this only
1777 * recognizes standard ASCII letters and ignores the locale, returning
1778 * all non-ASCII characters unchanged, even if they are upper case
1779 * letters in a particular character set. Also unlike the standard
1780 * library function, this takes and returns a char, not an int, so
1781 * don't call it on %EOF but no need to worry about casting to #guchar
1782 * before passing a possibly non-ASCII character in.
1784 * Return value: the result of converting @c to upper case.
1785 * If @c is not an ASCII lower case letter,
1786 * @c is returned unchanged.
1789 g_ascii_toupper (gchar c)
1791 return g_ascii_islower (c) ? c - 'a' + 'A' : c;
1795 * g_ascii_digit_value:
1796 * @c: an ASCII character.
1798 * Determines the numeric value of a character as a decimal
1799 * digit. Differs from g_unichar_digit_value() because it takes
1800 * a char, so there's no worry about sign extension if characters
1803 * Return value: If @c is a decimal digit (according to
1804 * g_ascii_isdigit()), its numeric value. Otherwise, -1.
1807 g_ascii_digit_value (gchar c)
1809 if (g_ascii_isdigit (c))
1815 * g_ascii_xdigit_value:
1816 * @c: an ASCII character.
1818 * Determines the numeric value of a character as a hexidecimal
1819 * digit. Differs from g_unichar_xdigit_value() because it takes
1820 * a char, so there's no worry about sign extension if characters
1823 * Return value: If @c is a hex digit (according to
1824 * g_ascii_isxdigit()), its numeric value. Otherwise, -1.
1827 g_ascii_xdigit_value (gchar c)
1829 if (c >= 'A' && c <= 'F')
1830 return c - 'A' + 10;
1831 if (c >= 'a' && c <= 'f')
1832 return c - 'a' + 10;
1833 return g_ascii_digit_value (c);
1837 * g_ascii_strcasecmp:
1838 * @s1: string to compare with @s2.
1839 * @s2: string to compare with @s1.
1841 * Compare two strings, ignoring the case of ASCII characters.
1843 * Unlike the BSD strcasecmp() function, this only recognizes standard
1844 * ASCII letters and ignores the locale, treating all non-ASCII
1845 * bytes as if they are not letters.
1847 * This function should be used only on strings that are known to be
1848 * in encodings where the bytes corresponding to ASCII letters always
1849 * represent themselves. This includes UTF-8 and the ISO-8859-*
1850 * charsets, but not for instance double-byte encodings like the
1851 * Windows Codepage 932, where the trailing bytes of double-byte
1852 * characters include all ASCII letters. If you compare two CP932
1853 * strings using this function, you will get false matches.
1855 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1856 * or a positive value if @s1 > @s2.
1859 g_ascii_strcasecmp (const gchar *s1,
1864 g_return_val_if_fail (s1 != NULL, 0);
1865 g_return_val_if_fail (s2 != NULL, 0);
1869 c1 = (gint)(guchar) TOLOWER (*s1);
1870 c2 = (gint)(guchar) TOLOWER (*s2);
1876 return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
1880 * g_ascii_strncasecmp:
1881 * @s1: string to compare with @s2.
1882 * @s2: string to compare with @s1.
1883 * @n: number of characters to compare.
1885 * Compare @s1 and @s2, ignoring the case of ASCII characters and any
1886 * characters after the first @n in each string.
1888 * Unlike the BSD strcasecmp() function, this only recognizes standard
1889 * ASCII letters and ignores the locale, treating all non-ASCII
1890 * characters as if they are not letters.
1892 * The same warning as in g_ascii_strcasecmp() applies: Use this
1893 * function only on strings known to be in encodings where bytes
1894 * corresponding to ASCII letters always represent themselves.
1896 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1897 * or a positive value if @s1 > @s2.
1900 g_ascii_strncasecmp (const gchar *s1,
1906 g_return_val_if_fail (s1 != NULL, 0);
1907 g_return_val_if_fail (s2 != NULL, 0);
1909 while (n && *s1 && *s2)
1912 c1 = (gint)(guchar) TOLOWER (*s1);
1913 c2 = (gint)(guchar) TOLOWER (*s2);
1920 return (((gint) (guchar) *s1) - ((gint) (guchar) *s2));
1928 * @s2: a string to compare with @s1.
1930 * A case-insensitive string comparison, corresponding to the standard
1931 * strcasecmp() function on platforms which support it.
1933 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1934 * or a positive value if @s1 > @s2.
1936 * Deprecated:2.2: See g_strncasecmp() for a discussion of why this function
1937 * is deprecated and how to replace it.
1940 g_strcasecmp (const gchar *s1,
1943 #ifdef HAVE_STRCASECMP
1944 g_return_val_if_fail (s1 != NULL, 0);
1945 g_return_val_if_fail (s2 != NULL, 0);
1947 return strcasecmp (s1, s2);
1951 g_return_val_if_fail (s1 != NULL, 0);
1952 g_return_val_if_fail (s2 != NULL, 0);
1956 /* According to A. Cox, some platforms have islower's that
1957 * don't work right on non-uppercase
1959 c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
1960 c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
1966 return (((gint)(guchar) *s1) - ((gint)(guchar) *s2));
1973 * @s2: a string to compare with @s1.
1974 * @n: the maximum number of characters to compare.
1976 * A case-insensitive string comparison, corresponding to the standard
1977 * strncasecmp() function on platforms which support it.
1978 * It is similar to g_strcasecmp() except it only compares the first @n
1979 * characters of the strings.
1981 * Return value: 0 if the strings match, a negative value if @s1 < @s2,
1982 * or a positive value if @s1 > @s2.
1984 * Deprecated:2.2: The problem with g_strncasecmp() is that it does the
1985 * comparison by calling toupper()/tolower(). These functions are
1986 * locale-specific and operate on single bytes. However, it is impossible
1987 * to handle things correctly from an I18N standpoint by operating on
1988 * bytes, since characters may be multibyte. Thus g_strncasecmp() is
1989 * broken if your string is guaranteed to be ASCII, since it's
1990 * locale-sensitive, and it's broken if your string is localized, since
1991 * it doesn't work on many encodings at all, including UTF-8, EUC-JP,
1994 * There are therefore two replacement functions: g_ascii_strncasecmp(),
1995 * which only works on ASCII and is not locale-sensitive, and
1996 * g_utf8_casefold(), which is good for case-insensitive sorting of UTF-8.
1999 g_strncasecmp (const gchar *s1,
2003 #ifdef HAVE_STRNCASECMP
2004 return strncasecmp (s1, s2, n);
2008 g_return_val_if_fail (s1 != NULL, 0);
2009 g_return_val_if_fail (s2 != NULL, 0);
2011 while (n && *s1 && *s2)
2014 /* According to A. Cox, some platforms have islower's that
2015 * don't work right on non-uppercase
2017 c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
2018 c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
2025 return (((gint) (guchar) *s1) - ((gint) (guchar) *s2));
2032 g_strdelimit (gchar *string,
2033 const gchar *delimiters,
2038 g_return_val_if_fail (string != NULL, NULL);
2041 delimiters = G_STR_DELIMITERS;
2043 for (c = string; *c; c++)
2045 if (strchr (delimiters, *c))
2053 g_strcanon (gchar *string,
2054 const gchar *valid_chars,
2059 g_return_val_if_fail (string != NULL, NULL);
2060 g_return_val_if_fail (valid_chars != NULL, NULL);
2062 for (c = string; *c; c++)
2064 if (!strchr (valid_chars, *c))
2072 g_strcompress (const gchar *source)
2074 const gchar *p = source, *octal;
2075 gchar *dest = g_malloc (strlen (source) + 1);
2086 g_warning ("g_strcompress: trailing \\");
2088 case '0': case '1': case '2': case '3': case '4':
2089 case '5': case '6': case '7':
2092 while ((p < octal + 3) && (*p >= '0') && (*p <= '7'))
2094 *q = (*q * 8) + (*p - '0');
2115 default: /* Also handles \" and \\ */
2131 g_strescape (const gchar *source,
2132 const gchar *exceptions)
2139 g_return_val_if_fail (source != NULL, NULL);
2141 p = (guchar *) source;
2142 /* Each source byte needs maximally four destination chars (\777) */
2143 q = dest = g_malloc (strlen (source) * 4 + 1);
2145 memset (excmap, 0, 256);
2148 guchar *e = (guchar *) exceptions;
2194 if ((*p < ' ') || (*p >= 0177))
2197 *q++ = '0' + (((*p) >> 6) & 07);
2198 *q++ = '0' + (((*p) >> 3) & 07);
2199 *q++ = '0' + ((*p) & 07);
2213 g_strchug (gchar *string)
2217 g_return_val_if_fail (string != NULL, NULL);
2219 for (start = (guchar*) string; *start && g_ascii_isspace (*start); start++)
2222 g_memmove (string, start, strlen ((gchar *) start) + 1);
2228 g_strchomp (gchar *string)
2232 g_return_val_if_fail (string != NULL, NULL);
2234 len = strlen (string);
2237 if (g_ascii_isspace ((guchar) string[len]))
2248 * @string: a string to split.
2249 * @delimiter: a string which specifies the places at which to split the string.
2250 * The delimiter is not included in any of the resulting strings, unless
2251 * @max_tokens is reached.
2252 * @max_tokens: the maximum number of pieces to split @string into. If this is
2253 * less than 1, the string is split completely.
2255 * Splits a string into a maximum of @max_tokens pieces, using the given
2256 * @delimiter. If @max_tokens is reached, the remainder of @string is appended
2257 * to the last token.
2259 * As a special case, the result of splitting the empty string "" is an empty
2260 * vector, not a vector containing a single string. The reason for this
2261 * special case is that being able to represent a empty vector is typically
2262 * more useful than consistent handling of empty elements. If you do need
2263 * to represent empty elements, you'll need to check for the empty string
2264 * before calling g_strsplit().
2266 * Return value: a newly-allocated %NULL-terminated array of strings. Use
2267 * g_strfreev() to free it.
2270 g_strsplit (const gchar *string,
2271 const gchar *delimiter,
2274 GSList *string_list = NULL, *slist;
2275 gchar **str_array, *s;
2277 const gchar *remainder;
2279 g_return_val_if_fail (string != NULL, NULL);
2280 g_return_val_if_fail (delimiter != NULL, NULL);
2281 g_return_val_if_fail (delimiter[0] != '\0', NULL);
2284 max_tokens = G_MAXINT;
2287 s = strstr (remainder, delimiter);
2290 gsize delimiter_len = strlen (delimiter);
2292 while (--max_tokens && s)
2296 len = s - remainder;
2297 string_list = g_slist_prepend (string_list,
2298 g_strndup (remainder, len));
2300 remainder = s + delimiter_len;
2301 s = strstr (remainder, delimiter);
2307 string_list = g_slist_prepend (string_list, g_strdup (remainder));
2310 str_array = g_new (gchar*, n + 1);
2312 str_array[n--] = NULL;
2313 for (slist = string_list; slist; slist = slist->next)
2314 str_array[n--] = slist->data;
2316 g_slist_free (string_list);
2323 * @string: The string to be tokenized
2324 * @delimiters: A nul-terminated string containing bytes that are used
2325 * to split the string.
2326 * @max_tokens: The maximum number of tokens to split @string into.
2327 * If this is less than 1, the string is split completely
2329 * Splits @string into a number of tokens not containing any of the characters
2330 * in @delimiter. A token is the (possibly empty) longest string that does not
2331 * contain any of the characters in @delimiters. If @max_tokens is reached, the
2332 * remainder is appended to the last token.
2334 * For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a
2335 * %NULL-terminated vector containing the three strings "abc", "def",
2338 * The result if g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated
2339 * vector containing the four strings "", "def", "ghi", and "".
2341 * As a special case, the result of splitting the empty string "" is an empty
2342 * vector, not a vector containing a single string. The reason for this
2343 * special case is that being able to represent a empty vector is typically
2344 * more useful than consistent handling of empty elements. If you do need
2345 * to represent empty elements, you'll need to check for the empty string
2346 * before calling g_strsplit_set().
2348 * Note that this function works on bytes not characters, so it can't be used
2349 * to delimit UTF-8 strings for anything but ASCII characters.
2351 * Return value: a newly-allocated %NULL-terminated array of strings. Use
2352 * g_strfreev() to free it.
2357 g_strsplit_set (const gchar *string,
2358 const gchar *delimiters,
2361 gboolean delim_table[256];
2362 GSList *tokens, *list;
2365 const gchar *current;
2369 g_return_val_if_fail (string != NULL, NULL);
2370 g_return_val_if_fail (delimiters != NULL, NULL);
2373 max_tokens = G_MAXINT;
2375 if (*string == '\0')
2377 result = g_new (char *, 1);
2382 memset (delim_table, FALSE, sizeof (delim_table));
2383 for (s = delimiters; *s != '\0'; ++s)
2384 delim_table[*(guchar *)s] = TRUE;
2389 s = current = string;
2392 if (delim_table[*(guchar *)s] && n_tokens + 1 < max_tokens)
2394 token = g_strndup (current, s - current);
2395 tokens = g_slist_prepend (tokens, token);
2404 token = g_strndup (current, s - current);
2405 tokens = g_slist_prepend (tokens, token);
2408 result = g_new (gchar *, n_tokens + 1);
2410 result[n_tokens] = NULL;
2411 for (list = tokens; list != NULL; list = list->next)
2412 result[--n_tokens] = list->data;
2414 g_slist_free (tokens);
2421 * @str_array: a %NULL-terminated array of strings to free.
2423 * Frees a %NULL-terminated array of strings, and the array itself.
2424 * If called on a %NULL value, g_strfreev() simply returns.
2427 g_strfreev (gchar **str_array)
2433 for (i = 0; str_array[i] != NULL; i++)
2434 g_free (str_array[i]);
2442 * @str_array: %NULL-terminated array of strings.
2444 * Copies %NULL-terminated array of strings. The copy is a deep copy;
2445 * the new array should be freed by first freeing each string, then
2446 * the array itself. g_strfreev() does this for you. If called
2447 * on a %NULL value, g_strdupv() simply returns %NULL.
2449 * Return value: a new %NULL-terminated array of strings.
2452 g_strdupv (gchar **str_array)
2460 while (str_array[i])
2463 retval = g_new (gchar*, i + 1);
2466 while (str_array[i])
2468 retval[i] = g_strdup (str_array[i]);
2480 g_strjoinv (const gchar *separator,
2486 g_return_val_if_fail (str_array != NULL, NULL);
2488 if (separator == NULL)
2495 gsize separator_len;
2497 separator_len = strlen (separator);
2498 /* First part, getting length */
2499 len = 1 + strlen (str_array[0]);
2500 for (i = 1; str_array[i] != NULL; i++)
2501 len += strlen (str_array[i]);
2502 len += separator_len * (i - 1);
2504 /* Second part, building string */
2505 string = g_new (gchar, len);
2506 ptr = g_stpcpy (string, *str_array);
2507 for (i = 1; str_array[i] != NULL; i++)
2509 ptr = g_stpcpy (ptr, separator);
2510 ptr = g_stpcpy (ptr, str_array[i]);
2514 string = g_strdup ("");
2520 g_strjoin (const gchar *separator,
2526 gsize separator_len;
2529 if (separator == NULL)
2532 separator_len = strlen (separator);
2534 va_start (args, separator);
2536 s = va_arg (args, gchar*);
2540 /* First part, getting length */
2541 len = 1 + strlen (s);
2543 s = va_arg (args, gchar*);
2546 len += separator_len + strlen (s);
2547 s = va_arg (args, gchar*);
2551 /* Second part, building string */
2552 string = g_new (gchar, len);
2554 va_start (args, separator);
2556 s = va_arg (args, gchar*);
2557 ptr = g_stpcpy (string, s);
2559 s = va_arg (args, gchar*);
2562 ptr = g_stpcpy (ptr, separator);
2563 ptr = g_stpcpy (ptr, s);
2564 s = va_arg (args, gchar*);
2568 string = g_strdup ("");
2578 * @haystack: a string.
2579 * @haystack_len: the maximum length of @haystack. Note that -1 is
2580 * a valid length, if @haystack is nul-terminated, meaning it will
2581 * search through the whole string.
2582 * @needle: the string to search for.
2584 * Searches the string @haystack for the first occurrence
2585 * of the string @needle, limiting the length of the search
2588 * Return value: a pointer to the found occurrence, or
2589 * %NULL if not found.
2592 g_strstr_len (const gchar *haystack,
2593 gssize haystack_len,
2594 const gchar *needle)
2596 g_return_val_if_fail (haystack != NULL, NULL);
2597 g_return_val_if_fail (needle != NULL, NULL);
2599 if (haystack_len < 0)
2600 return strstr (haystack, needle);
2603 const gchar *p = haystack;
2604 gsize needle_len = strlen (needle);
2608 if (needle_len == 0)
2609 return (gchar *)haystack;
2611 if (haystack_len < needle_len)
2614 end = haystack + haystack_len - needle_len;
2616 while (p <= end && *p)
2618 for (i = 0; i < needle_len; i++)
2619 if (p[i] != needle[i])
2634 * @haystack: a nul-terminated string.
2635 * @needle: the nul-terminated string to search for.
2637 * Searches the string @haystack for the last occurrence
2638 * of the string @needle.
2640 * Return value: a pointer to the found occurrence, or
2641 * %NULL if not found.
2644 g_strrstr (const gchar *haystack,
2645 const gchar *needle)
2652 g_return_val_if_fail (haystack != NULL, NULL);
2653 g_return_val_if_fail (needle != NULL, NULL);
2655 needle_len = strlen (needle);
2656 haystack_len = strlen (haystack);
2658 if (needle_len == 0)
2659 return (gchar *)haystack;
2661 if (haystack_len < needle_len)
2664 p = haystack + haystack_len - needle_len;
2666 while (p >= haystack)
2668 for (i = 0; i < needle_len; i++)
2669 if (p[i] != needle[i])
2683 * @haystack: a nul-terminated string.
2684 * @haystack_len: the maximum length of @haystack.
2685 * @needle: the nul-terminated string to search for.
2687 * Searches the string @haystack for the last occurrence
2688 * of the string @needle, limiting the length of the search
2691 * Return value: a pointer to the found occurrence, or
2692 * %NULL if not found.
2695 g_strrstr_len (const gchar *haystack,
2696 gssize haystack_len,
2697 const gchar *needle)
2699 g_return_val_if_fail (haystack != NULL, NULL);
2700 g_return_val_if_fail (needle != NULL, NULL);
2702 if (haystack_len < 0)
2703 return g_strrstr (haystack, needle);
2706 gsize needle_len = strlen (needle);
2707 const gchar *haystack_max = haystack + haystack_len;
2708 const gchar *p = haystack;
2711 while (p < haystack_max && *p)
2714 if (p < haystack + needle_len)
2719 while (p >= haystack)
2721 for (i = 0; i < needle_len; i++)
2722 if (p[i] != needle[i])
2738 * @str: a nul-terminated string.
2739 * @suffix: the nul-terminated suffix to look for.
2741 * Looks whether the string @str ends with @suffix.
2743 * Return value: %TRUE if @str end with @suffix, %FALSE otherwise.
2748 g_str_has_suffix (const gchar *str,
2749 const gchar *suffix)
2754 g_return_val_if_fail (str != NULL, FALSE);
2755 g_return_val_if_fail (suffix != NULL, FALSE);
2757 str_len = strlen (str);
2758 suffix_len = strlen (suffix);
2760 if (str_len < suffix_len)
2763 return strcmp (str + str_len - suffix_len, suffix) == 0;
2768 * @str: a nul-terminated string.
2769 * @prefix: the nul-terminated prefix to look for.
2771 * Looks whether the string @str begins with @prefix.
2773 * Return value: %TRUE if @str begins with @prefix, %FALSE otherwise.
2778 g_str_has_prefix (const gchar *str,
2779 const gchar *prefix)
2784 g_return_val_if_fail (str != NULL, FALSE);
2785 g_return_val_if_fail (prefix != NULL, FALSE);
2787 str_len = strlen (str);
2788 prefix_len = strlen (prefix);
2790 if (str_len < prefix_len)
2793 return strncmp (str, prefix, prefix_len) == 0;
2800 * @msgval: another string
2802 * An auxiliary function for gettext() support (see Q_()).
2804 * Return value: @msgval, unless @msgval is identical to @msgid and contains
2805 * a '|' character, in which case a pointer to the substring of msgid after
2806 * the first '|' character is returned.
2810 G_CONST_RETURN gchar *
2811 g_strip_context (const gchar *msgid,
2812 const gchar *msgval)
2814 if (msgval == msgid)
2816 const char *c = strchr (msgid, '|');
2827 * @str_array: a %NULL-terminated array of strings.
2829 * Returns the length of the given %NULL-terminated
2830 * string array @str_array.
2832 * Return value: length of @str_array.
2837 g_strv_length (gchar **str_array)
2841 g_return_val_if_fail (str_array != NULL, 0);
2843 while (str_array[i])
2852 * @domain: the translation domain to use, or %NULL to use
2853 * the domain set with textdomain()
2854 * @msgctxtid: a combined message context and message id, separated
2855 * by a \004 character
2856 * @msgidoffset: the offset of the message id in @msgctxid
2858 * This function is a variant of g_dgettext() which supports
2859 * a disambiguating message context. GNU gettext uses the
2860 * '\004' character to separate the message context and
2861 * message id in @msgctxtid.
2862 * If 0 is passed as @msgidoffset, this function will fall back to
2863 * trying to use the deprecated convention of using "|" as a separation
2866 * This uses g_dgettext() internally. See that functions for differences
2867 * with dgettext() proper.
2869 * Applications should normally not use this function directly,
2870 * but use the C_() macro for translations with context.
2872 * Returns: The translated string
2876 G_CONST_RETURN gchar *
2877 g_dpgettext (const gchar *domain,
2878 const gchar *msgctxtid,
2881 const gchar *translation;
2884 translation = g_dgettext (domain, msgctxtid);
2886 if (translation == msgctxtid)
2888 if (msgidoffset > 0)
2889 return msgctxtid + msgidoffset;
2891 sep = strchr (msgctxtid, '|');
2895 /* try with '\004' instead of '|', in case
2896 * xgettext -kQ_:1g was used
2898 gchar *tmp = g_alloca (strlen (msgctxtid) + 1);
2899 strcpy (tmp, msgctxtid);
2900 tmp[sep - msgctxtid] = '\004';
2902 translation = g_dgettext (domain, tmp);
2904 if (translation == tmp)
2912 /* This function is taken from gettext.h
2913 * GNU gettext uses '\004' to separate context and msgid in .mo files.
2917 * @domain: the translation domain to use, or %NULL to use
2918 * the domain set with textdomain()
2919 * @context: the message context
2920 * @msgid: the message
2922 * This function is a variant of g_dgettext() which supports
2923 * a disambiguating message context. GNU gettext uses the
2924 * '\004' character to separate the message context and
2925 * message id in @msgctxtid.
2927 * This uses g_dgettext() internally. See that functions for differences
2928 * with dgettext() proper.
2930 * This function differs from C_() in that it is not a macro and
2931 * thus you may use non-string-literals as context and msgid arguments.
2933 * Returns: The translated string
2937 G_CONST_RETURN char *
2938 g_dpgettext2 (const char *domain,
2939 const char *msgctxt,
2942 size_t msgctxt_len = strlen (msgctxt) + 1;
2943 size_t msgid_len = strlen (msgid) + 1;
2944 const char *translation;
2947 msg_ctxt_id = g_alloca (msgctxt_len + msgid_len);
2949 memcpy (msg_ctxt_id, msgctxt, msgctxt_len - 1);
2950 msg_ctxt_id[msgctxt_len - 1] = '\004';
2951 memcpy (msg_ctxt_id + msgctxt_len, msgid, msgid_len);
2953 translation = g_dgettext (domain, msg_ctxt_id);
2955 if (translation == msg_ctxt_id)
2957 /* try the old way of doing message contexts, too */
2958 msg_ctxt_id[msgctxt_len - 1] = '|';
2959 translation = g_dgettext (domain, msg_ctxt_id);
2961 if (translation == msg_ctxt_id)
2969 _g_dgettext_should_translate (void)
2971 static gsize translate = 0;
2973 SHOULD_TRANSLATE = 1,
2974 SHOULD_NOT_TRANSLATE = 2
2977 if (G_UNLIKELY (g_once_init_enter (&translate)))
2979 gboolean should_translate = TRUE;
2981 const char *default_domain = textdomain (NULL);
2982 const char *translator_comment = gettext ("");
2984 const char *translate_locale = setlocale (LC_MESSAGES, NULL);
2986 const char *translate_locale = g_win32_getlocale ();
2988 /* We should NOT translate only if all the following hold:
2989 * - user has called textdomain() and set textdomain to non-default
2990 * - default domain has no translations
2991 * - locale does not start with "en_" and is not "C"
2994 * - If text domain is still the default domain, maybe user calls
2995 * it later. Continue with old behavior of translating.
2996 * - If locale starts with "en_", we can continue using the
2997 * translations even if the app doesn't have translations for
2998 * this locale. That is, en_UK and en_CA for example.
2999 * - If locale is "C", maybe user calls setlocale(LC_ALL,"") later.
3000 * Continue with old behavior of translating.
3002 if (0 != strcmp (default_domain, "messages") &&
3003 '\0' == *translator_comment &&
3004 0 != strncmp (translate_locale, "en_", 3) &&
3005 0 != strcmp (translate_locale, "C"))
3006 should_translate = FALSE;
3008 g_once_init_leave (&translate,
3011 SHOULD_NOT_TRANSLATE);
3014 return translate == SHOULD_TRANSLATE;
3019 * @domain: the translation domain to use, or %NULL to use
3020 * the domain set with textdomain()
3021 * @msgid: message to translate
3023 * This function is a wrapper of dgettext() which does not translate
3024 * the message if the default domain as set with textdomain() has no
3025 * translations for the current locale.
3027 * The advantage of using this function over dgettext() proper is that
3028 * libraries using this function (like GTK+) will not use translations
3029 * if the application using the library does not have translations for
3030 * the current locale. This results in a consistent English-only
3031 * interface instead of one having partial translations. For this
3032 * feature to work, the call to textdomain() and setlocale() should
3033 * precede any g_dgettext() invocations. For GTK+, it means calling
3034 * textdomain() before gtk_init or its variants.
3036 * This function disables translations if and only if upon its first
3037 * call all the following conditions hold:
3039 * <listitem>@domain is not %NULL</listitem>
3040 * <listitem>textdomain() has been called to set a default text domain</listitem>
3041 * <listitem>there is no translations available for the default text domain
3042 * and the current locale</listitem>
3043 * <listitem>current locale is not "C" or any English locales (those
3044 * starting with "en_")</listitem>
3047 * Note that this behavior may not be desired for example if an application
3048 * has its untranslated messages in a language other than English. In those
3049 * cases the application should call textdomain() after initializing GTK+.
3051 * Applications should normally not use this function directly,
3052 * but use the _() macro for translations.
3054 * Returns: The translated string
3058 G_CONST_RETURN gchar *
3059 g_dgettext (const gchar *domain,
3062 if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
3065 return dgettext (domain, msgid);
3070 * @domain: the translation domain to use, or %NULL to use
3071 * the domain set with textdomain()
3072 * @msgid: message to translate
3073 * @msgid_plural: plural form of the message
3074 * @n: the quantity for which translation is needed
3076 * This function is a wrapper of dngettext() which does not translate
3077 * the message if the default domain as set with textdomain() has no
3078 * translations for the current locale.
3080 * See g_dgettext() for details of how this differs from dngettext()
3083 * Returns: The translated string
3087 G_CONST_RETURN gchar *
3088 g_dngettext (const gchar *domain,
3090 const gchar *msgid_plural,
3093 if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
3094 return n == 1 ? msgid : msgid_plural;
3096 return dngettext (domain, msgid, msgid_plural, n);
3100 #define __G_STRFUNCS_C__
3101 #include "galiasdef.c"