*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* Modified by the GLib Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GLib Team. See the ChangeLog
* files for a list of changes. These files are distributed with
- * GLib at ftp://ftp.gtk.org/pub/gtk/.
+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
*/
/*
#include "config.h"
-#define _GNU_SOURCE /* For stpcpy */
-
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <errno.h>
-#include <ctype.h> /* For tolower() */
+#include <ctype.h> /* For tolower() */
#if !defined (HAVE_STRSIGNAL) || !defined(NO_SYS_SIGLIST_DECL)
#include <signal.h>
#endif
-#include "galias.h"
-#include "glib.h"
+#include "gstrfuncs.h"
+
#include "gprintf.h"
#include "gprintfint.h"
+#include "glibintl.h"
+
#ifdef G_OS_WIN32
#include <windows.h>
const guint16 * const g_ascii_table = ascii_table_data;
+/**
+ * g_strdup:
+ * @str: the string to duplicate
+ *
+ * Duplicates a string. If @str is %NULL it returns %NULL.
+ * The returned string should be freed with g_free()
+ * when no longer needed.
+ *
+ * Returns: a newly-allocated copy of @str
+ */
gchar*
g_strdup (const gchar *str)
{
return new_str;
}
+/**
+ * g_memdup:
+ * @mem: the memory to copy.
+ * @byte_size: the number of bytes to copy.
+ *
+ * Allocates @byte_size bytes of memory, and copies @byte_size bytes into it
+ * from @mem. If @mem is %NULL it returns %NULL.
+ *
+ * Returns: a pointer to the newly-allocated copy of the memory, or %NULL if @mem
+ * is %NULL.
+ */
gpointer
g_memdup (gconstpointer mem,
- guint byte_size)
+ guint byte_size)
{
gpointer new_mem;
return new_mem;
}
+/**
+ * g_strndup:
+ * @str: the string to duplicate
+ * @n: the maximum number of bytes to copy from @str
+ *
+ * Duplicates the first @n bytes of a string, returning a newly-allocated
+ * buffer @n + 1 bytes long which will always be nul-terminated.
+ * If @str is less than @n bytes long the buffer is padded with nuls.
+ * If @str is %NULL it returns %NULL.
+ * The returned value should be freed when no longer needed.
+ *
+ * <note><para>
+ * To copy a number of characters from a UTF-8 encoded string, use
+ * g_utf8_strncpy() instead.
+ * </para></note>
+ *
+ * Returns: a newly-allocated buffer containing the first @n bytes
+ * of @str, nul-terminated
+ */
gchar*
g_strndup (const gchar *str,
- gsize n)
+ gsize n)
{
gchar *new_str;
return new_str;
}
+/**
+ * g_strnfill:
+ * @length: the length of the new string
+ * @fill_char: the byte to fill the string with
+ *
+ * Creates a new string @length bytes long filled with @fill_char.
+ * The returned string should be freed when no longer needed.
+ *
+ * Returns: a newly-allocated string filled the @fill_char
+ */
gchar*
-g_strnfill (gsize length,
- gchar fill_char)
+g_strnfill (gsize length,
+ gchar fill_char)
{
gchar *str;
* g_stpcpy:
* @dest: destination buffer.
* @src: source string.
- *
+ *
* Copies a nul-terminated string into the dest buffer, include the
* trailing nul, and return a pointer to the trailing nul byte.
* This is useful for concatenating multiple strings together
* without having to repeatedly scan for the end.
- *
+ *
* Return value: a pointer to trailing nul byte.
**/
gchar *
#endif
}
+/**
+ * g_strdup_vprintf:
+ * @format: a standard printf() format string, but notice
+ * <link linkend="string-precision">string precision pitfalls</link>
+ * @args: the list of parameters to insert into the format string
+ *
+ * Similar to the standard C vsprintf() function but safer, since it
+ * calculates the maximum space required and allocates memory to hold
+ * the result. The returned string should be freed with g_free() when
+ * no longer needed.
+ *
+ * See also g_vasprintf(), which offers the same functionality, but
+ * additionally returns the length of the allocated string.
+ *
+ * Returns: a newly-allocated string holding the result
+ */
gchar*
g_strdup_vprintf (const gchar *format,
- va_list args)
+ va_list args)
{
gchar *string = NULL;
return string;
}
+/**
+ * g_strdup_printf:
+ * @format: a standard printf() format string, but notice
+ * <link linkend="string-precision">string precision pitfalls</link>
+ * @...: the parameters to insert into the format string
+ *
+ * Similar to the standard C sprintf() function but safer, since it
+ * calculates the maximum space required and allocates memory to hold
+ * the result. The returned string should be freed with g_free() when no
+ * longer needed.
+ *
+ * Returns: a newly-allocated string holding the result
+ */
gchar*
g_strdup_printf (const gchar *format,
- ...)
+ ...)
{
gchar *buffer;
va_list args;
return buffer;
}
+/**
+ * g_strconcat:
+ * @string1: the first string to add, which must not be %NULL
+ * @...: a %NULL-terminated list of strings to append to the string
+ *
+ * Concatenates all of the given strings into one long string.
+ * The returned string should be freed with g_free() when no longer needed.
+ *
+ * Note that this function is usually not the right function to use to
+ * assemble a translated message from pieces, since proper translation
+ * often requires the pieces to be reordered.
+ *
+ * <warning><para>The variable argument list <emphasis>must</emphasis> end
+ * with %NULL. If you forget the %NULL, g_strconcat() will start appending
+ * random memory junk to your string.</para></warning>
+ *
+ * Returns: a newly-allocated string containing all the string arguments
+ */
gchar*
g_strconcat (const gchar *string1, ...)
{
- gsize l;
+ gsize l;
va_list args;
- gchar *s;
- gchar *concat;
+ gchar *s;
+ gchar *concat;
gchar *ptr;
if (!string1)
* @nptr: the string to convert to a numeric value.
* @endptr: if non-%NULL, it returns the character after
* the last character used in the conversion.
- *
+ *
* Converts a string to a #gdouble value.
* It calls the standard strtod() function to handle the conversion, but
* if the string is not completely converted it attempts the conversion
* should you use this. Make sure that you don't pass strings such as comma
* separated lists of values, since the commas may be interpreted as a decimal
* point in some locales, causing unexpected results.
- *
+ *
* Return value: the #gdouble value.
**/
gdouble
g_strtod (const gchar *nptr,
- gchar **endptr)
+ gchar **endptr)
{
gchar *fail_pos_1;
gchar *fail_pos_2;
if (!fail_pos_1 || fail_pos_1[0] == 0 || fail_pos_1 >= fail_pos_2)
{
if (endptr)
- *endptr = fail_pos_1;
+ *endptr = fail_pos_1;
return val_1;
}
else
{
if (endptr)
- *endptr = fail_pos_2;
+ *endptr = fail_pos_2;
return val_2;
}
}
* @nptr: the string to convert to a numeric value.
* @endptr: if non-%NULL, it returns the character after
* the last character used in the conversion.
- *
+ *
* Converts a string to a #gdouble value.
+ *
* This function behaves like the standard strtod() function
- * does in the C locale. It does this without actually
- * changing the current locale, since that would not be
- * thread-safe.
+ * does in the C locale. It does this without actually changing
+ * the current locale, since that would not be thread-safe.
+ * A limitation of the implementation is that this function
+ * will still accept localized versions of infinities and NANs.
*
* This function is typically used when reading configuration
* files or other non-user input that should be locale independent.
* is returned (according to the sign of the value), and %ERANGE is
* stored in %errno. If the correct value would cause underflow,
* zero is returned and %ERANGE is stored in %errno.
- *
+ *
* This function resets %errno before calling strtod() so that
* you can reliably detect overflow and underflow.
*
**/
gdouble
g_ascii_strtod (const gchar *nptr,
- gchar **endptr)
+ gchar **endptr)
{
gchar *fail_pos;
gdouble val;
decimal_point_len = strlen (decimal_point);
g_assert (decimal_point_len != 0);
-
+
decimal_point_pos = NULL;
end = NULL;
- if (decimal_point[0] != '.' ||
+ if (decimal_point[0] != '.' ||
decimal_point[1] != 0)
{
p = nptr;
/* Skip leading space */
while (g_ascii_isspace (*p))
- p++;
-
+ p++;
+
/* Skip leading optional sign */
if (*p == '+' || *p == '-')
- p++;
-
- if (p[0] == '0' &&
- (p[1] == 'x' || p[1] == 'X'))
- {
- p += 2;
- /* HEX - find the (optional) decimal point */
-
- while (g_ascii_isxdigit (*p))
- p++;
-
- if (*p == '.')
- decimal_point_pos = p++;
-
- while (g_ascii_isxdigit (*p))
- p++;
-
- if (*p == 'p' || *p == 'P')
- p++;
- if (*p == '+' || *p == '-')
- p++;
- while (g_ascii_isdigit (*p))
- p++;
-
- end = p;
- }
+ p++;
+
+ if (p[0] == '0' &&
+ (p[1] == 'x' || p[1] == 'X'))
+ {
+ p += 2;
+ /* HEX - find the (optional) decimal point */
+
+ while (g_ascii_isxdigit (*p))
+ p++;
+
+ if (*p == '.')
+ decimal_point_pos = p++;
+
+ while (g_ascii_isxdigit (*p))
+ p++;
+
+ if (*p == 'p' || *p == 'P')
+ p++;
+ if (*p == '+' || *p == '-')
+ p++;
+ while (g_ascii_isdigit (*p))
+ p++;
+
+ end = p;
+ }
else if (g_ascii_isdigit (*p) || *p == '.')
- {
- while (g_ascii_isdigit (*p))
- p++;
-
- if (*p == '.')
- decimal_point_pos = p++;
-
- while (g_ascii_isdigit (*p))
- p++;
-
- if (*p == 'e' || *p == 'E')
- p++;
- if (*p == '+' || *p == '-')
- p++;
- while (g_ascii_isdigit (*p))
- p++;
-
- end = p;
- }
+ {
+ while (g_ascii_isdigit (*p))
+ p++;
+
+ if (*p == '.')
+ decimal_point_pos = p++;
+
+ while (g_ascii_isdigit (*p))
+ p++;
+
+ if (*p == 'e' || *p == 'E')
+ p++;
+ if (*p == '+' || *p == '-')
+ p++;
+ while (g_ascii_isdigit (*p))
+ p++;
+
+ end = p;
+ }
/* For the other cases, we need not convert the decimal point */
}
/* We need to convert the '.' to the locale specific decimal point */
copy = g_malloc (end - nptr + 1 + decimal_point_len);
-
+
c = copy;
memcpy (c, nptr, decimal_point_pos - nptr);
c += decimal_point_pos - nptr;
strtod_errno = errno;
if (fail_pos)
- {
- if (fail_pos - copy > decimal_point_pos - nptr)
- fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);
- else
- fail_pos = (char *)nptr + (fail_pos - copy);
- }
-
+ {
+ if (fail_pos - copy > decimal_point_pos - nptr)
+ fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);
+ else
+ fail_pos = (char *)nptr + (fail_pos - copy);
+ }
+
g_free (copy);
-
+
}
else if (end)
{
char *copy;
-
+
copy = g_malloc (end - (char *)nptr + 1);
memcpy (copy, nptr, end - nptr);
*(copy + (end - (char *)nptr)) = 0;
-
+
errno = 0;
val = strtod (copy, &fail_pos);
strtod_errno = errno;
if (fail_pos)
- {
- fail_pos = (char *)nptr + (fail_pos - copy);
- }
-
+ {
+ fail_pos = (char *)nptr + (fail_pos - copy);
+ }
+
g_free (copy);
}
else
* @d: The #gdouble to convert
*
* Converts a #gdouble to a string, using the '.' as
- * decimal point.
- *
+ * decimal point.
+ *
* This functions generates enough precision that converting
* the string back using g_ascii_strtod() gives the same machine-number
* (on machines with IEEE compatible 64bit doubles). It is
**/
gchar *
g_ascii_dtostr (gchar *buffer,
- gint buf_len,
- gdouble d)
+ gint buf_len,
+ gdouble d)
{
return g_ascii_formatd (buffer, buf_len, "%.17g", d);
}
* @buffer: A buffer to place the resulting string in
* @buf_len: The length of the buffer.
* @format: The printf()-style format to use for the
- * code to use for converting.
+ * code to use for converting.
* @d: The #gdouble to convert
*
* Converts a #gdouble to a string, using the '.' as
* decimal point. To format the number you pass in
* a printf()-style format string. Allowed conversion
- * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
- *
+ * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
+ *
* If you just want to want to serialize the value into a
* string, use g_ascii_dtostr().
*
* Return value: The pointer to the buffer with the converted string.
- **/
+ */
gchar *
g_ascii_formatd (gchar *buffer,
- gint buf_len,
- const gchar *format,
- gdouble d)
+ gint buf_len,
+ const gchar *format,
+ gdouble d)
{
struct lconv *locale_data;
const char *decimal_point;
g_return_val_if_fail (buffer != NULL, NULL);
g_return_val_if_fail (format[0] == '%', NULL);
g_return_val_if_fail (strpbrk (format + 1, "'l%") == NULL, NULL);
-
+
format_char = format[strlen (format) - 1];
-
+
g_return_val_if_fail (format_char == 'e' || format_char == 'E' ||
- format_char == 'f' || format_char == 'F' ||
- format_char == 'g' || format_char == 'G',
- NULL);
+ format_char == 'f' || format_char == 'F' ||
+ format_char == 'g' || format_char == 'G',
+ NULL);
if (format[0] != '%')
return NULL;
return NULL;
if (!(format_char == 'e' || format_char == 'E' ||
- format_char == 'f' || format_char == 'F' ||
- format_char == 'g' || format_char == 'G'))
+ format_char == 'f' || format_char == 'F' ||
+ format_char == 'g' || format_char == 'G'))
return NULL;
-
_g_snprintf (buffer, buf_len, format, d);
locale_data = localeconv ();
{
p = buffer;
+ while (g_ascii_isspace (*p))
+ p++;
+
if (*p == '+' || *p == '-')
- p++;
+ p++;
while (isdigit ((guchar)*p))
- p++;
+ p++;
if (strncmp (p, decimal_point, decimal_point_len) == 0)
- {
- *p = '.';
- p++;
- if (decimal_point_len > 1) {
- rest_len = strlen (p + (decimal_point_len-1));
- memmove (p, p + (decimal_point_len-1),
- rest_len);
- p[rest_len] = 0;
-
- }
- }
+ {
+ *p = '.';
+ p++;
+ if (decimal_point_len > 1)
+ {
+ rest_len = strlen (p + (decimal_point_len-1));
+ memmove (p, p + (decimal_point_len-1), rest_len);
+ p[rest_len] = 0;
+ }
+ }
}
-
+
return buffer;
}
-/**
- * g_ascii_strtoull:
- * @nptr: the string to convert to a numeric value.
- * @endptr: if non-%NULL, it returns the character after
- * the last character used in the conversion.
- * @base: to be used for the conversion, 2..36 or 0
- *
- * Converts a string to a #guint64 value.
- * This function behaves like the standard strtoull() function
- * does in the C locale. It does this without actually
- * changing the current locale, since that would not be
- * thread-safe.
- *
- * This function is typically used when reading configuration
- * files or other non-user input that should be locale independent.
- * To handle input from the user you should normally use the
- * locale-sensitive system strtoull() function.
- *
- * If the correct value would cause overflow, %G_MAXUINT64
- * is returned, and %ERANGE is stored in %errno.
- *
- * Return value: the #guint64 value.
- *
- * Since: 2.2
- **/
-guint64
-g_ascii_strtoull (const gchar *nptr,
- gchar **endptr,
- guint base)
+static guint64
+g_parse_long_long (const gchar *nptr,
+ const gchar **endptr,
+ guint base,
+ gboolean *negative)
{
/* this code is based on on the strtol(3) code from GNU libc released under
* the GNU Lesser General Public License.
* Copyright (C) 1991,92,94,95,96,97,98,99,2000,01,02
* Free Software Foundation, Inc.
*/
-#define ISSPACE(c) ((c) == ' ' || (c) == '\f' || (c) == '\n' || \
- (c) == '\r' || (c) == '\t' || (c) == '\v')
-#define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
-#define ISLOWER(c) ((c) >= 'a' && (c) <= 'z')
-#define ISALPHA(c) (ISUPPER (c) || ISLOWER (c))
-#define TOUPPER(c) (ISLOWER (c) ? (c) - 'a' + 'A' : (c))
-#define TOLOWER(c) (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
- gboolean negative, overflow;
+#define ISSPACE(c) ((c) == ' ' || (c) == '\f' || (c) == '\n' || \
+ (c) == '\r' || (c) == '\t' || (c) == '\v')
+#define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z')
+#define ISLOWER(c) ((c) >= 'a' && (c) <= 'z')
+#define ISALPHA(c) (ISUPPER (c) || ISLOWER (c))
+#define TOUPPER(c) (ISLOWER (c) ? (c) - 'a' + 'A' : (c))
+#define TOLOWER(c) (ISUPPER (c) ? (c) - 'A' + 'a' : (c))
+ gboolean overflow;
guint64 cutoff;
guint64 cutlim;
guint64 ui64;
const gchar *s, *save;
guchar c;
-
+
g_return_val_if_fail (nptr != NULL, 0);
-
+
+ *negative = FALSE;
if (base == 1 || base > 36)
{
errno = EINVAL;
+ if (endptr)
+ *endptr = nptr;
return 0;
}
-
+
save = s = nptr;
-
+
/* Skip white space. */
while (ISSPACE (*s))
++s;
- if (!*s)
+
+ if (G_UNLIKELY (!*s))
goto noconv;
-
+
/* Check for a sign. */
- negative = FALSE;
if (*s == '-')
{
- negative = TRUE;
+ *negative = TRUE;
++s;
}
else if (*s == '+')
++s;
-
+
/* Recognize number prefix and if BASE is zero, figure it out ourselves. */
if (*s == '0')
{
if ((base == 0 || base == 16) && TOUPPER (s[1]) == 'X')
- {
- s += 2;
- base = 16;
- }
+ {
+ s += 2;
+ base = 16;
+ }
else if (base == 0)
- base = 8;
+ base = 8;
}
else if (base == 0)
base = 10;
-
+
/* Save the pointer so we can check later if anything happened. */
save = s;
cutoff = G_MAXUINT64 / base;
cutlim = G_MAXUINT64 % base;
-
+
overflow = FALSE;
ui64 = 0;
c = *s;
for (; c; c = *++s)
{
if (c >= '0' && c <= '9')
- c -= '0';
+ c -= '0';
else if (ISALPHA (c))
- c = TOUPPER (c) - 'A' + 10;
+ c = TOUPPER (c) - 'A' + 10;
else
- break;
+ break;
if (c >= base)
- break;
+ break;
/* Check for overflow. */
if (ui64 > cutoff || (ui64 == cutoff && c > cutlim))
- overflow = TRUE;
+ overflow = TRUE;
else
- {
- ui64 *= base;
- ui64 += c;
- }
+ {
+ ui64 *= base;
+ ui64 += c;
+ }
}
-
+
/* Check if anything actually happened. */
if (s == save)
goto noconv;
-
+
/* Store in ENDPTR the address of one character
past the last character we converted. */
if (endptr)
- *endptr = (gchar*) s;
-
- if (overflow)
+ *endptr = s;
+
+ if (G_UNLIKELY (overflow))
{
errno = ERANGE;
return G_MAXUINT64;
}
-
- /* Return the result of the appropriate sign. */
- return negative ? -ui64 : ui64;
-
+
+ return ui64;
+
noconv:
/* We must handle a special case here: the base is 0 or 16 and the
first two characters are '0' and 'x', but the rest are no
if (endptr)
{
if (save - nptr >= 2 && TOUPPER (save[-1]) == 'X'
- && save[-2] == '0')
- *endptr = (gchar*) &save[-1];
+ && save[-2] == '0')
+ *endptr = &save[-1];
else
- /* There was no number to convert. */
- *endptr = (gchar*) nptr;
+ /* There was no number to convert. */
+ *endptr = nptr;
}
return 0;
}
+/**
+ * g_ascii_strtoull:
+ * @nptr: the string to convert to a numeric value.
+ * @endptr: if non-%NULL, it returns the character after
+ * the last character used in the conversion.
+ * @base: to be used for the conversion, 2..36 or 0
+ *
+ * Converts a string to a #guint64 value.
+ * This function behaves like the standard strtoull() function
+ * does in the C locale. It does this without actually
+ * changing the current locale, since that would not be
+ * thread-safe.
+ *
+ * This function is typically used when reading configuration
+ * files or other non-user input that should be locale independent.
+ * To handle input from the user you should normally use the
+ * locale-sensitive system strtoull() function.
+ *
+ * If the correct value would cause overflow, %G_MAXUINT64
+ * is returned, and %ERANGE is stored in %errno. If the base is
+ * outside the valid range, zero is returned, and %EINVAL is stored
+ * in %errno. If the string conversion fails, zero is returned, and
+ * @endptr returns @nptr (if @endptr is non-%NULL).
+ *
+ * Return value: the #guint64 value or zero on error.
+ *
+ * Since: 2.2
+ */
+guint64
+g_ascii_strtoull (const gchar *nptr,
+ gchar **endptr,
+ guint base)
+{
+ gboolean negative;
+ guint64 result;
+
+ result = g_parse_long_long (nptr, (const gchar **) endptr, base, &negative);
+
+ /* Return the result of the appropriate sign. */
+ return negative ? -result : result;
+}
-G_CONST_RETURN gchar*
+/**
+ * g_ascii_strtoll:
+ * @nptr: the string to convert to a numeric value.
+ * @endptr: if non-%NULL, it returns the character after
+ * the last character used in the conversion.
+ * @base: to be used for the conversion, 2..36 or 0
+ *
+ * Converts a string to a #gint64 value.
+ * This function behaves like the standard strtoll() function
+ * does in the C locale. It does this without actually
+ * changing the current locale, since that would not be
+ * thread-safe.
+ *
+ * This function is typically used when reading configuration
+ * files or other non-user input that should be locale independent.
+ * To handle input from the user you should normally use the
+ * locale-sensitive system strtoll() function.
+ *
+ * If the correct value would cause overflow, %G_MAXINT64 or %G_MININT64
+ * is returned, and %ERANGE is stored in %errno. If the base is
+ * outside the valid range, zero is returned, and %EINVAL is stored
+ * in %errno. If the string conversion fails, zero is returned, and
+ * @endptr returns @nptr (if @endptr is non-%NULL).
+ *
+ * Return value: the #gint64 value or zero on error.
+ *
+ * Since: 2.12
+ */
+gint64
+g_ascii_strtoll (const gchar *nptr,
+ gchar **endptr,
+ guint base)
+{
+ gboolean negative;
+ guint64 result;
+
+ result = g_parse_long_long (nptr, (const gchar **) endptr, base, &negative);
+
+ if (negative && result > (guint64) G_MININT64)
+ {
+ errno = ERANGE;
+ return G_MININT64;
+ }
+ else if (!negative && result > (guint64) G_MAXINT64)
+ {
+ errno = ERANGE;
+ return G_MAXINT64;
+ }
+ else if (negative)
+ return - (gint64) result;
+ else
+ return (gint64) result;
+}
+
+/**
+ * g_strerror:
+ * @errnum: the system error number. See the standard C %errno
+ * documentation
+ *
+ * Returns a string corresponding to the given error code, e.g.
+ * "no such process". You should use this function in preference to
+ * strerror(), because it returns a string in UTF-8 encoding, and since
+ * not all platforms support the strerror() function.
+ *
+ * Returns: a UTF-8 string describing the error code. If the error code
+ * is unknown, it returns "unknown error (<code>)". The string
+ * can only be used until the next call to g_strerror()
+ */
+const gchar *
g_strerror (gint errnum)
{
static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
{
gchar *msg_utf8 = g_locale_to_utf8 (msg_locale, -1, NULL, NULL, NULL);
if (msg_utf8)
- {
- /* Stick in the quark table so that we can return a static result
- */
- GQuark msg_quark = g_quark_from_string (msg_utf8);
- g_free (msg_utf8);
-
- msg_utf8 = (gchar *) g_quark_to_string (msg_quark);
- errno = saved_errno;
- return msg_utf8;
- }
+ {
+ /* Stick in the quark table so that we can return a static result
+ */
+ GQuark msg_quark = g_quark_from_string (msg_utf8);
+ g_free (msg_utf8);
+
+ msg_utf8 = (gchar *) g_quark_to_string (msg_quark);
+ errno = saved_errno;
+ return msg_utf8;
+ }
}
#elif NO_SYS_ERRLIST
switch (errnum)
#if defined(EDEADLK) && (!defined(EWOULDBLOCK) || (EDEADLK != EWOULDBLOCK))
case EDEADLK: return "resource deadlock avoided";
#endif
-#ifdef EDEADLOCK
+#if defined(EDEADLOCK) && (!defined(EDEADLK) || (EDEADLOCK != EDEADLK))
case EDEADLOCK: return "resource deadlock avoided";
#endif
#ifdef EDESTADDRREQ
return msg;
}
-G_CONST_RETURN gchar*
+/**
+ * g_strsignal:
+ * @signum: the signal number. See the <literal>signal</literal>
+ * documentation
+ *
+ * Returns a string describing the given signal, e.g. "Segmentation fault".
+ * You should use this function in preference to strsignal(), because it
+ * returns a string in UTF-8 encoding, and since not all platforms support
+ * the strsignal() function.
+ *
+ * Returns: a UTF-8 string describing the signal. If the signal is unknown,
+ * it returns "unknown signal (<signum>)". The string can only be
+ * used until the next call to g_strsignal()
+ */
+const gchar *
g_strsignal (gint signum)
{
static GStaticPrivate msg_private = G_STATIC_PRIVATE_INIT;
#ifdef HAVE_STRSIGNAL
const char *msg_locale;
-
+
#if defined(G_OS_BEOS) || defined(G_WITH_CYGWIN)
extern const char *strsignal(int);
#else
{
gchar *msg_utf8 = g_locale_to_utf8 (msg_locale, -1, NULL, NULL, NULL);
if (msg_utf8)
- {
- /* Stick in the quark table so that we can return a static result
- */
- GQuark msg_quark = g_quark_from_string (msg_utf8);
- g_free (msg_utf8);
-
- return g_quark_to_string (msg_quark);
- }
+ {
+ /* Stick in the quark table so that we can return a static result
+ */
+ GQuark msg_quark = g_quark_from_string (msg_utf8);
+ g_free (msg_utf8);
+
+ return g_quark_to_string (msg_quark);
+ }
}
#elif NO_SYS_SIGLIST
switch (signum)
#else /* NO_SYS_SIGLIST */
#ifdef NO_SYS_SIGLIST_DECL
- extern char *sys_siglist[]; /*(see Tue Jan 19 00:44:24 1999 in changelog)*/
+ extern char *sys_siglist[]; /*(see Tue Jan 19 00:44:24 1999 in changelog)*/
#endif
return (char*) /* this function should return const --josh */ sys_siglist [signum];
}
_g_sprintf (msg, "unknown signal (%d)", signum);
-
+
return msg;
}
/* Use the native ones, if available; they might be implemented in assembly */
gsize
g_strlcpy (gchar *dest,
- const gchar *src,
- gsize dest_size)
+ const gchar *src,
+ gsize dest_size)
{
g_return_val_if_fail (dest != NULL, 0);
g_return_val_if_fail (src != NULL, 0);
-
+
return strlcpy (dest, src, dest_size);
}
gsize
g_strlcat (gchar *dest,
- const gchar *src,
- gsize dest_size)
+ const gchar *src,
+ gsize dest_size)
{
g_return_val_if_fail (dest != NULL, 0);
g_return_val_if_fail (src != NULL, 0);
-
+
return strlcat (dest, src, dest_size);
}
#else /* ! HAVE_STRLCPY */
-/* g_strlcpy
- *
- * Copy string src to buffer dest (of buffer size dest_size). At most
- * dest_size-1 characters will be copied. Always NUL terminates
- * (unless dest_size == 0). This function does NOT allocate memory.
- * Unlike strncpy, this function doesn't pad dest (so it's often faster).
- * Returns size of attempted result, strlen(src),
- * so if retval >= dest_size, truncation occurred.
+/**
+ * g_strlcpy:
+ * @dest: destination buffer
+ * @src: source buffer
+ * @dest_size: length of @dest in bytes
+ *
+ * Portability wrapper that calls strlcpy() on systems which have it,
+ * and emulates strlcpy() otherwise. Copies @src to @dest; @dest is
+ * guaranteed to be nul-terminated; @src must be nul-terminated;
+ * @dest_size is the buffer size, not the number of chars to copy.
+ *
+ * At most dest_size - 1 characters will be copied. Always nul-terminates
+ * (unless dest_size == 0). This function does <emphasis>not</emphasis>
+ * allocate memory. Unlike strncpy(), this function doesn't pad dest (so
+ * it's often faster). It returns the size of the attempted result,
+ * strlen (src), so if @retval >= @dest_size, truncation occurred.
+ *
+ * <note><para>Caveat: strlcpy() is supposedly more secure than
+ * strcpy() or strncpy(), but if you really want to avoid screwups,
+ * g_strdup() is an even better idea.</para></note>
+ *
+ * Returns: length of @src
*/
gsize
g_strlcpy (gchar *dest,
register gchar *d = dest;
register const gchar *s = src;
register gsize n = dest_size;
-
+
g_return_val_if_fail (dest != NULL, 0);
g_return_val_if_fail (src != NULL, 0);
-
+
/* Copy as many bytes as will fit */
if (n != 0 && --n != 0)
do
{
- register gchar c = *s++;
-
- *d++ = c;
- if (c == 0)
- break;
+ register gchar c = *s++;
+
+ *d++ = c;
+ if (c == 0)
+ break;
}
while (--n != 0);
-
+
/* If not enough room in dest, add NUL and traverse rest of src */
if (n == 0)
{
if (dest_size != 0)
- *d = 0;
+ *d = 0;
while (*s++)
- ;
+ ;
}
-
+
return s - src - 1; /* count does not include NUL */
}
-/* g_strlcat
+/**
+ * g_strlcat:
+ * @dest: destination buffer, already containing one nul-terminated string
+ * @src: source buffer
+ * @dest_size: length of @dest buffer in bytes (not length of existing string
+ * inside @dest)
+ *
+ * Portability wrapper that calls strlcat() on systems which have it,
+ * and emulates it otherwise. Appends nul-terminated @src string to @dest,
+ * guaranteeing nul-termination for @dest. The total size of @dest won't
+ * exceed @dest_size.
*
- * Appends string src to buffer dest (of buffer size dest_size).
- * At most dest_size-1 characters will be copied.
+ * At most dest_size - 1 characters will be copied.
* Unlike strncat, dest_size is the full size of dest, not the space left over.
* This function does NOT allocate memory.
* This always NUL terminates (unless siz == 0 or there were no NUL characters
* in the dest_size characters of dest to start with).
- * Returns size of attempted result, which is
- * MIN (dest_size, strlen (original dest)) + strlen (src),
- * so if retval >= dest_size, truncation occurred.
- */
+ *
+ * <note><para>Caveat: this is supposedly a more secure alternative to
+ * strcat() or strncat(), but for real security g_strconcat() is harder
+ * to mess up.</para></note>
+ *
+ * Returns: size of attempted result, which is MIN (dest_size, strlen
+ * (original dest)) + strlen (src), so if retval >= dest_size,
+ * truncation occurred.
+ **/
gsize
g_strlcat (gchar *dest,
const gchar *src,
register const gchar *s = src;
register gsize bytes_left = dest_size;
gsize dlength; /* Logically, MIN (strlen (d), dest_size) */
-
+
g_return_val_if_fail (dest != NULL, 0);
g_return_val_if_fail (src != NULL, 0);
-
+
/* Find the end of dst and adjust bytes left but don't go past end */
while (*d != 0 && bytes_left-- != 0)
d++;
dlength = d - dest;
bytes_left = dest_size - dlength;
-
+
if (bytes_left == 0)
return dlength + strlen (s);
-
+
while (*s != 0)
{
if (bytes_left != 1)
- {
- *d++ = *s;
- bytes_left--;
- }
+ {
+ *d++ = *s;
+ bytes_left--;
+ }
s++;
}
*d = 0;
-
+
return dlength + (s - src); /* count does not include NUL */
}
#endif /* ! HAVE_STRLCPY */
* g_ascii_strdown:
* @str: a string.
* @len: length of @str in bytes, or -1 if @str is nul-terminated.
- *
+ *
* Converts all upper case ASCII letters to lower case ASCII letters.
- *
+ *
* Return value: a newly-allocated string, with all the upper case
* characters in @str converted to lower case, with
* semantics that exactly match g_ascii_tolower(). (Note
**/
gchar*
g_ascii_strdown (const gchar *str,
- gssize len)
+ gssize len)
{
gchar *result, *s;
-
+
g_return_val_if_fail (str != NULL, NULL);
if (len < 0)
result = g_strndup (str, len);
for (s = result; *s; s++)
*s = g_ascii_tolower (*s);
-
+
return result;
}
* g_ascii_strup:
* @str: a string.
* @len: length of @str in bytes, or -1 if @str is nul-terminated.
- *
+ *
* Converts all lower case ASCII letters to upper case ASCII letters.
- *
+ *
* Return value: a newly allocated string, with all the lower case
* characters in @str converted to upper case, with
* semantics that exactly match g_ascii_toupper(). (Note
**/
gchar*
g_ascii_strup (const gchar *str,
- gssize len)
+ gssize len)
{
gchar *result, *s;
/**
* g_strdown:
* @string: the string to convert.
- *
- * Converts a string to lower case.
- *
- * Return value: the string
*
- * Deprecated: This function is totally broken for the reasons discussed in
- * the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown()
+ * Converts a string to lower case.
+ *
+ * Return value: the string
+ *
+ * Deprecated:2.2: This function is totally broken for the reasons discussed
+ * in the g_strncasecmp() docs - use g_ascii_strdown() or g_utf8_strdown()
* instead.
**/
gchar*
g_strdown (gchar *string)
{
register guchar *s;
-
+
g_return_val_if_fail (string != NULL, NULL);
-
+
s = (guchar *) string;
-
+
while (*s)
{
if (isupper (*s))
- *s = tolower (*s);
+ *s = tolower (*s);
s++;
}
-
+
return (gchar *) string;
}
/**
* g_strup:
* @string: the string to convert.
- *
- * Converts a string to upper case.
- *
+ *
+ * Converts a string to upper case.
+ *
* Return value: the string
*
- * Deprecated: This function is totally broken for the reasons discussed in
- * the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.
+ * Deprecated:2.2: This function is totally broken for the reasons discussed
+ * in the g_strncasecmp() docs - use g_ascii_strup() or g_utf8_strup() instead.
**/
gchar*
g_strup (gchar *string)
while (*s)
{
if (islower (*s))
- *s = toupper (*s);
+ *s = toupper (*s);
s++;
}
return (gchar *) string;
}
+/**
+ * g_strreverse:
+ * @string: the string to reverse
+ *
+ * Reverses all of the bytes in a string. For example,
+ * <literal>g_strreverse ("abcdef")</literal> will result
+ * in "fedcba".
+ *
+ * Note that g_strreverse() doesn't work on UTF-8 strings
+ * containing multibyte characters. For that purpose, use
+ * g_utf8_strreverse().
+ *
+ * Returns: the same pointer passed in as @string
+ */
gchar*
g_strreverse (gchar *string)
{
t = string + strlen (string) - 1;
while (h < t)
- {
- register gchar c;
-
- c = *h;
- *h = *t;
- h++;
- *t = c;
- t--;
- }
+ {
+ register gchar c;
+
+ c = *h;
+ *h = *t;
+ h++;
+ *t = c;
+ t--;
+ }
}
return string;
/**
* g_ascii_tolower:
* @c: any character.
- *
+ *
* Convert a character to ASCII lower case.
*
* Unlike the standard C library tolower() function, this only
* library function, this takes and returns a char, not an int, so
* don't call it on %EOF but no need to worry about casting to #guchar
* before passing a possibly non-ASCII character in.
- *
+ *
* Return value: the result of converting @c to lower case.
* If @c is not an ASCII upper case letter,
* @c is returned unchanged.
/**
* g_ascii_toupper:
* @c: any character.
- *
+ *
* Convert a character to ASCII upper case.
*
* Unlike the standard C library toupper() function, this only
* library function, this takes and returns a char, not an int, so
* don't call it on %EOF but no need to worry about casting to #guchar
* before passing a possibly non-ASCII character in.
- *
+ *
* Return value: the result of converting @c to upper case.
* If @c is not an ASCII lower case letter,
* @c is returned unchanged.
* g_ascii_strcasecmp:
* @s1: string to compare with @s2.
* @s2: string to compare with @s1.
- *
+ *
* Compare two strings, ignoring the case of ASCII characters.
*
* Unlike the BSD strcasecmp() function, this only recognizes standard
* ASCII letters and ignores the locale, treating all non-ASCII
- * characters as if they are not letters.
- *
- * Return value: an integer less than, equal to, or greater than
- * zero if @s1 is found, respectively, to be less than,
- * to match, or to be greater than @s2.
+ * bytes as if they are not letters.
+ *
+ * This function should be used only on strings that are known to be
+ * in encodings where the bytes corresponding to ASCII letters always
+ * represent themselves. This includes UTF-8 and the ISO-8859-*
+ * charsets, but not for instance double-byte encodings like the
+ * Windows Codepage 932, where the trailing bytes of double-byte
+ * characters include all ASCII letters. If you compare two CP932
+ * strings using this function, you will get false matches.
+ *
+ * Return value: 0 if the strings match, a negative value if @s1 < @s2,
+ * or a positive value if @s1 > @s2.
**/
gint
g_ascii_strcasecmp (const gchar *s1,
- const gchar *s2)
+ const gchar *s2)
{
gint c1, c2;
c1 = (gint)(guchar) TOLOWER (*s1);
c2 = (gint)(guchar) TOLOWER (*s2);
if (c1 != c2)
- return (c1 - c2);
+ return (c1 - c2);
s1++; s2++;
}
* @s1: string to compare with @s2.
* @s2: string to compare with @s1.
* @n: number of characters to compare.
- *
+ *
* Compare @s1 and @s2, ignoring the case of ASCII characters and any
* characters after the first @n in each string.
*
* Unlike the BSD strcasecmp() function, this only recognizes standard
* ASCII letters and ignores the locale, treating all non-ASCII
* characters as if they are not letters.
- *
- * Return value: an integer less than, equal to, or greater than zero
- * if the first @n bytes of @s1 is found, respectively,
- * to be less than, to match, or to be greater than the
- * first @n bytes of @s2.
+ *
+ * The same warning as in g_ascii_strcasecmp() applies: Use this
+ * function only on strings known to be in encodings where bytes
+ * corresponding to ASCII letters always represent themselves.
+ *
+ * Return value: 0 if the strings match, a negative value if @s1 < @s2,
+ * or a positive value if @s1 > @s2.
**/
gint
g_ascii_strncasecmp (const gchar *s1,
- const gchar *s2,
- gsize n)
+ const gchar *s2,
+ gsize n)
{
gint c1, c2;
c1 = (gint)(guchar) TOLOWER (*s1);
c2 = (gint)(guchar) TOLOWER (*s2);
if (c1 != c2)
- return (c1 - c2);
+ return (c1 - c2);
s1++; s2++;
}
* g_strcasecmp:
* @s1: a string.
* @s2: a string to compare with @s1.
- *
+ *
* A case-insensitive string comparison, corresponding to the standard
* strcasecmp() function on platforms which support it.
*
- * Return value: 0 if the strings match, a negative value if @s1 < @s2,
+ * Return value: 0 if the strings match, a negative value if @s1 < @s2,
* or a positive value if @s1 > @s2.
*
- * Deprecated: See g_strncasecmp() for a discussion of why this function is
- * deprecated and how to replace it.
+ * Deprecated:2.2: See g_strncasecmp() for a discussion of why this function
+ * is deprecated and how to replace it.
**/
gint
g_strcasecmp (const gchar *s1,
- const gchar *s2)
+ const gchar *s2)
{
#ifdef HAVE_STRCASECMP
g_return_val_if_fail (s1 != NULL, 0);
c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
if (c1 != c2)
- return (c1 - c2);
+ return (c1 - c2);
s1++; s2++;
}
* @s1: a string.
* @s2: a string to compare with @s1.
* @n: the maximum number of characters to compare.
- *
+ *
* A case-insensitive string comparison, corresponding to the standard
* strncasecmp() function on platforms which support it.
- * It is similar to g_strcasecmp() except it only compares the first @n
+ * It is similar to g_strcasecmp() except it only compares the first @n
* characters of the strings.
- *
- * Return value: 0 if the strings match, a negative value if @s1 < @s2,
+ *
+ * Return value: 0 if the strings match, a negative value if @s1 < @s2,
* or a positive value if @s1 > @s2.
*
- * Deprecated: The problem with g_strncasecmp() is that it does the
+ * Deprecated:2.2: The problem with g_strncasecmp() is that it does the
* comparison by calling toupper()/tolower(). These functions are
* locale-specific and operate on single bytes. However, it is impossible
* to handle things correctly from an I18N standpoint by operating on
**/
gint
g_strncasecmp (const gchar *s1,
- const gchar *s2,
- guint n)
+ const gchar *s2,
+ guint n)
{
#ifdef HAVE_STRNCASECMP
return strncasecmp (s1, s2, n);
c1 = isupper ((guchar)*s1) ? tolower ((guchar)*s1) : *s1;
c2 = isupper ((guchar)*s2) ? tolower ((guchar)*s2) : *s2;
if (c1 != c2)
- return (c1 - c2);
+ return (c1 - c2);
s1++; s2++;
}
}
gchar*
-g_strdelimit (gchar *string,
- const gchar *delimiters,
- gchar new_delim)
+g_strdelimit (gchar *string,
+ const gchar *delimiters,
+ gchar new_delim)
{
register gchar *c;
for (c = string; *c; c++)
{
if (strchr (delimiters, *c))
- *c = new_delim;
+ *c = new_delim;
}
return string;
gchar*
g_strcanon (gchar *string,
- const gchar *valid_chars,
- gchar substitutor)
+ const gchar *valid_chars,
+ gchar substitutor)
{
register gchar *c;
for (c = string; *c; c++)
{
if (!strchr (valid_chars, *c))
- *c = substitutor;
+ *c = substitutor;
}
return string;
const gchar *p = source, *octal;
gchar *dest = g_malloc (strlen (source) + 1);
gchar *q = dest;
-
+
while (*p)
{
if (*p == '\\')
- {
- p++;
- switch (*p)
- {
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7':
- *q = 0;
- octal = p;
- while ((p < octal + 3) && (*p >= '0') && (*p <= '7'))
- {
- *q = (*q * 8) + (*p - '0');
- p++;
- }
- q++;
- p--;
- break;
- case 'b':
- *q++ = '\b';
- break;
- case 'f':
- *q++ = '\f';
- break;
- case 'n':
- *q++ = '\n';
- break;
- case 'r':
- *q++ = '\r';
- break;
- case 't':
- *q++ = '\t';
- break;
- default: /* Also handles \" and \\ */
- *q++ = *p;
- break;
- }
- }
+ {
+ p++;
+ switch (*p)
+ {
+ case '\0':
+ g_warning ("g_strcompress: trailing \\");
+ goto out;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7':
+ *q = 0;
+ octal = p;
+ while ((p < octal + 3) && (*p >= '0') && (*p <= '7'))
+ {
+ *q = (*q * 8) + (*p - '0');
+ p++;
+ }
+ q++;
+ p--;
+ break;
+ case 'b':
+ *q++ = '\b';
+ break;
+ case 'f':
+ *q++ = '\f';
+ break;
+ case 'n':
+ *q++ = '\n';
+ break;
+ case 'r':
+ *q++ = '\r';
+ break;
+ case 't':
+ *q++ = '\t';
+ break;
+ default: /* Also handles \" and \\ */
+ *q++ = *p;
+ break;
+ }
+ }
else
- *q++ = *p;
+ *q++ = *p;
p++;
}
+out:
*q = 0;
-
+
return dest;
}
gchar *
g_strescape (const gchar *source,
- const gchar *exceptions)
+ const gchar *exceptions)
{
const guchar *p;
gchar *dest;
gchar *q;
guchar excmap[256];
-
+
g_return_val_if_fail (source != NULL, NULL);
p = (guchar *) source;
guchar *e = (guchar *) exceptions;
while (*e)
- {
- excmap[*e] = 1;
- e++;
- }
+ {
+ excmap[*e] = 1;
+ e++;
+ }
}
while (*p)
{
if (excmap[*p])
- *q++ = *p;
+ *q++ = *p;
else
- {
- switch (*p)
- {
- case '\b':
- *q++ = '\\';
- *q++ = 'b';
- break;
- case '\f':
- *q++ = '\\';
- *q++ = 'f';
- break;
- case '\n':
- *q++ = '\\';
- *q++ = 'n';
- break;
- case '\r':
- *q++ = '\\';
- *q++ = 'r';
- break;
- case '\t':
- *q++ = '\\';
- *q++ = 't';
- break;
- case '\\':
- *q++ = '\\';
- *q++ = '\\';
- break;
- case '"':
- *q++ = '\\';
- *q++ = '"';
- break;
- default:
- if ((*p < ' ') || (*p >= 0177))
- {
- *q++ = '\\';
- *q++ = '0' + (((*p) >> 6) & 07);
- *q++ = '0' + (((*p) >> 3) & 07);
- *q++ = '0' + ((*p) & 07);
- }
- else
- *q++ = *p;
- break;
- }
- }
+ {
+ switch (*p)
+ {
+ case '\b':
+ *q++ = '\\';
+ *q++ = 'b';
+ break;
+ case '\f':
+ *q++ = '\\';
+ *q++ = 'f';
+ break;
+ case '\n':
+ *q++ = '\\';
+ *q++ = 'n';
+ break;
+ case '\r':
+ *q++ = '\\';
+ *q++ = 'r';
+ break;
+ case '\t':
+ *q++ = '\\';
+ *q++ = 't';
+ break;
+ case '\\':
+ *q++ = '\\';
+ *q++ = '\\';
+ break;
+ case '"':
+ *q++ = '\\';
+ *q++ = '"';
+ break;
+ default:
+ if ((*p < ' ') || (*p >= 0177))
+ {
+ *q++ = '\\';
+ *q++ = '0' + (((*p) >> 6) & 07);
+ *q++ = '0' + (((*p) >> 3) & 07);
+ *q++ = '0' + ((*p) & 07);
+ }
+ else
+ *q++ = *p;
+ break;
+ }
+ }
p++;
}
*q = 0;
while (len--)
{
if (g_ascii_isspace ((guchar) string[len]))
- string[len] = '\0';
+ string[len] = '\0';
else
- break;
+ break;
}
return string;
* @max_tokens is reached.
* @max_tokens: the maximum number of pieces to split @string into. If this is
* less than 1, the string is split completely.
- *
+ *
* Splits a string into a maximum of @max_tokens pieces, using the given
* @delimiter. If @max_tokens is reached, the remainder of @string is appended
- * to the last token.
+ * to the last token.
*
* As a special case, the result of splitting the empty string "" is an empty
* vector, not a vector containing a single string. The reason for this
* more useful than consistent handling of empty elements. If you do need
* to represent empty elements, you'll need to check for the empty string
* before calling g_strsplit().
- *
- * Return value: a newly-allocated %NULL-terminated array of strings. Use
+ *
+ * Return value: a newly-allocated %NULL-terminated array of strings. Use
* g_strfreev() to free it.
**/
gchar**
g_strsplit (const gchar *string,
- const gchar *delimiter,
- gint max_tokens)
+ const gchar *delimiter,
+ gint max_tokens)
{
GSList *string_list = NULL, *slist;
gchar **str_array, *s;
s = strstr (remainder, delimiter);
if (s)
{
- gsize delimiter_len = strlen (delimiter);
+ gsize delimiter_len = strlen (delimiter);
while (--max_tokens && s)
- {
- gsize len;
- gchar *new_string;
-
- len = s - remainder;
- new_string = g_new (gchar, len + 1);
- strncpy (new_string, remainder, len);
- new_string[len] = 0;
- string_list = g_slist_prepend (string_list, new_string);
- n++;
- remainder = s + delimiter_len;
- s = strstr (remainder, delimiter);
- }
+ {
+ gsize len;
+
+ len = s - remainder;
+ string_list = g_slist_prepend (string_list,
+ g_strndup (remainder, len));
+ n++;
+ remainder = s + delimiter_len;
+ s = strstr (remainder, delimiter);
+ }
}
if (*string)
{
* @string: The string to be tokenized
* @delimiters: A nul-terminated string containing bytes that are used
* to split the string.
- * @max_tokens: The maximum number of tokens to split @string into.
+ * @max_tokens: The maximum number of tokens to split @string into.
* If this is less than 1, the string is split completely
- *
+ *
* Splits @string into a number of tokens not containing any of the characters
* in @delimiter. A token is the (possibly empty) longest string that does not
* contain any of the characters in @delimiters. If @max_tokens is reached, the
* remainder is appended to the last token.
*
* For example the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is a
- * %NULL-terminated vector containing the three strings "abc", "def",
+ * %NULL-terminated vector containing the three strings "abc", "def",
* and "ghi".
*
* The result if g_strsplit_set (":def/ghi:", ":/", -1) is a %NULL-terminated
* vector containing the four strings "", "def", "ghi", and "".
- *
+ *
* As a special case, the result of splitting the empty string "" is an empty
* vector, not a vector containing a single string. The reason for this
* special case is that being able to represent a empty vector is typically
* to represent empty elements, you'll need to check for the empty string
* before calling g_strsplit_set().
*
- * Note that this function works on bytes not characters, so it can't be used
+ * Note that this function works on bytes not characters, so it can't be used
* to delimit UTF-8 strings for anything but ASCII characters.
- *
- * Return value: a newly-allocated %NULL-terminated array of strings. Use
+ *
+ * Return value: a newly-allocated %NULL-terminated array of strings. Use
* g_strfreev() to free it.
- *
+ *
* Since: 2.4
**/
gchar **
g_strsplit_set (const gchar *string,
- const gchar *delimiters,
- gint max_tokens)
+ const gchar *delimiters,
+ gint max_tokens)
{
gboolean delim_table[256];
GSList *tokens, *list;
const gchar *current;
gchar *token;
gchar **result;
-
+
g_return_val_if_fail (string != NULL, NULL);
g_return_val_if_fail (delimiters != NULL, NULL);
result[0] = NULL;
return result;
}
-
+
memset (delim_table, FALSE, sizeof (delim_table));
for (s = delimiters; *s != '\0'; ++s)
delim_table[*(guchar *)s] = TRUE;
while (*s != '\0')
{
if (delim_table[*(guchar *)s] && n_tokens + 1 < max_tokens)
- {
- gchar *token;
+ {
+ token = g_strndup (current, s - current);
+ tokens = g_slist_prepend (tokens, token);
+ ++n_tokens;
- token = g_strndup (current, s - current);
- tokens = g_slist_prepend (tokens, token);
- ++n_tokens;
+ current = s + 1;
+ }
- current = s + 1;
- }
-
++s;
}
result[--n_tokens] = list->data;
g_slist_free (tokens);
-
+
return result;
}
* @str_array: a %NULL-terminated array of strings to free.
* Frees a %NULL-terminated array of strings, and the array itself.
- * If called on a %NULL value, g_strfreev() simply returns.
+ * If called on a %NULL value, g_strfreev() simply returns.
**/
void
g_strfreev (gchar **str_array)
{
int i;
- for(i = 0; str_array[i] != NULL; i++)
- g_free(str_array[i]);
+ for (i = 0; str_array[i] != NULL; i++)
+ g_free (str_array[i]);
g_free (str_array);
}
/**
* g_strdupv:
* @str_array: %NULL-terminated array of strings.
- *
+ *
* Copies %NULL-terminated array of strings. The copy is a deep copy;
* the new array should be freed by first freeing each string, then
* the array itself. g_strfreev() does this for you. If called
* on a %NULL value, g_strdupv() simply returns %NULL.
- *
+ *
* Return value: a new %NULL-terminated array of strings.
**/
gchar**
i = 0;
while (str_array[i])
++i;
-
+
retval = g_new (gchar*, i + 1);
i = 0;
return NULL;
}
+/**
+ * g_strjoinv:
+ * @separator: a string to insert between each of the strings, or %NULL
+ * @str_array: a %NULL-terminated array of strings to join
+ *
+ * Joins a number of strings together to form one long string, with the
+ * optional @separator inserted between each of them. The returned string
+ * should be freed with g_free().
+ *
+ * Returns: a newly-allocated string containing all of the strings joined
+ * together, with @separator between them
+ */
gchar*
g_strjoinv (const gchar *separator,
- gchar **str_array)
+ gchar **str_array)
{
gchar *string;
gchar *ptr;
{
gint i;
gsize len;
- gsize separator_len;
+ gsize separator_len;
separator_len = strlen (separator);
/* First part, getting length */
string = g_new (gchar, len);
ptr = g_stpcpy (string, *str_array);
for (i = 1; str_array[i] != NULL; i++)
- {
+ {
ptr = g_stpcpy (ptr, separator);
ptr = g_stpcpy (ptr, str_array[i]);
- }
+ }
}
else
string = g_strdup ("");
return string;
}
+/**
+ * g_strjoin:
+ * @separator: a string to insert between each of the strings, or %NULL
+ * @...: a %NULL-terminated list of strings to join
+ *
+ * Joins a number of strings together to form one long string, with the
+ * optional @separator inserted between each of them. The returned string
+ * should be freed with g_free().
+ *
+ * Returns: a newly-allocated string containing all of the strings joined
+ * together, with @separator between them
+ */
gchar*
g_strjoin (const gchar *separator,
- ...)
+ ...)
{
gchar *string, *s;
va_list args;
- gsize len;
- gsize separator_len;
+ gsize len;
+ gsize separator_len;
gchar *ptr;
if (separator == NULL)
s = va_arg (args, gchar*);
while (s)
- {
- len += separator_len + strlen (s);
- s = va_arg (args, gchar*);
- }
+ {
+ len += separator_len + strlen (s);
+ s = va_arg (args, gchar*);
+ }
va_end (args);
/* Second part, building string */
s = va_arg (args, gchar*);
while (s)
- {
- ptr = g_stpcpy (ptr, separator);
+ {
+ ptr = g_stpcpy (ptr, separator);
ptr = g_stpcpy (ptr, s);
- s = va_arg (args, gchar*);
- }
+ s = va_arg (args, gchar*);
+ }
}
else
string = g_strdup ("");
/**
* g_strstr_len:
* @haystack: a string.
- * @haystack_len: the maximum length of @haystack.
+ * @haystack_len: the maximum length of @haystack. Note that -1 is
+ * a valid length, if @haystack is nul-terminated, meaning it will
+ * search through the whole string.
* @needle: the string to search for.
*
* Searches the string @haystack for the first occurrence
* of the string @needle, limiting the length of the search
- * to @haystack_len.
+ * to @haystack_len.
*
* Return value: a pointer to the found occurrence, or
* %NULL if not found.
**/
gchar *
g_strstr_len (const gchar *haystack,
- gssize haystack_len,
- const gchar *needle)
+ gssize haystack_len,
+ const gchar *needle)
{
g_return_val_if_fail (haystack != NULL, NULL);
g_return_val_if_fail (needle != NULL, NULL);
-
+
if (haystack_len < 0)
return strstr (haystack, needle);
else
gsize i;
if (needle_len == 0)
- return (gchar *)haystack;
+ return (gchar *)haystack;
if (haystack_len < needle_len)
- return NULL;
-
+ return NULL;
+
end = haystack + haystack_len - needle_len;
-
- while (*p && p <= end)
- {
- for (i = 0; i < needle_len; i++)
- if (p[i] != needle[i])
- goto next;
-
- return (gchar *)p;
-
- next:
- p++;
- }
-
+
+ while (p <= end && *p)
+ {
+ for (i = 0; i < needle_len; i++)
+ if (p[i] != needle[i])
+ goto next;
+
+ return (gchar *)p;
+
+ next:
+ p++;
+ }
+
return NULL;
}
}
**/
gchar *
g_strrstr (const gchar *haystack,
- const gchar *needle)
+ const gchar *needle)
{
gsize i;
gsize needle_len;
gsize haystack_len;
const gchar *p;
-
+
g_return_val_if_fail (haystack != NULL, NULL);
g_return_val_if_fail (needle != NULL, NULL);
if (haystack_len < needle_len)
return NULL;
-
+
p = haystack + haystack_len - needle_len;
while (p >= haystack)
{
for (i = 0; i < needle_len; i++)
- if (p[i] != needle[i])
- goto next;
-
+ if (p[i] != needle[i])
+ goto next;
+
return (gchar *)p;
-
+
next:
p--;
}
-
+
return NULL;
}
*
* Searches the string @haystack for the last occurrence
* of the string @needle, limiting the length of the search
- * to @haystack_len.
+ * to @haystack_len.
*
* Return value: a pointer to the found occurrence, or
* %NULL if not found.
**/
gchar *
g_strrstr_len (const gchar *haystack,
- gssize haystack_len,
- const gchar *needle)
+ gssize haystack_len,
+ const gchar *needle)
{
g_return_val_if_fail (haystack != NULL, NULL);
g_return_val_if_fail (needle != NULL, NULL);
-
+
if (haystack_len < 0)
return g_strrstr (haystack, needle);
else
gsize i;
while (p < haystack_max && *p)
- p++;
+ p++;
if (p < haystack + needle_len)
- return NULL;
-
+ return NULL;
+
p -= needle_len;
while (p >= haystack)
- {
- for (i = 0; i < needle_len; i++)
- if (p[i] != needle[i])
- goto next;
-
- return (gchar *)p;
-
- next:
- p--;
- }
+ {
+ for (i = 0; i < needle_len; i++)
+ if (p[i] != needle[i])
+ goto next;
+
+ return (gchar *)p;
+
+ next:
+ p--;
+ }
return NULL;
}
**/
gboolean
g_str_has_suffix (const gchar *str,
- const gchar *suffix)
+ const gchar *suffix)
{
int str_len;
int suffix_len;
-
+
g_return_val_if_fail (str != NULL, FALSE);
g_return_val_if_fail (suffix != NULL, FALSE);
**/
gboolean
g_str_has_prefix (const gchar *str,
- const gchar *prefix)
+ const gchar *prefix)
{
int str_len;
int prefix_len;
-
+
g_return_val_if_fail (str != NULL, FALSE);
g_return_val_if_fail (prefix != NULL, FALSE);
if (str_len < prefix_len)
return FALSE;
-
+
return strncmp (str, prefix, prefix_len) == 0;
}
* g_strip_context:
* @msgid: a string
* @msgval: another string
- *
+ *
* An auxiliary function for gettext() support (see Q_()).
- *
+ *
* Return value: @msgval, unless @msgval is identical to @msgid and contains
* a '|' character, in which case a pointer to the substring of msgid after
- * the first '|' character is returned.
+ * the first '|' character is returned.
*
* Since: 2.4
**/
-G_CONST_RETURN gchar *
-g_strip_context (const gchar *msgid,
- const gchar *msgval)
+const gchar *
+g_strip_context (const gchar *msgid,
+ const gchar *msgval)
{
if (msgval == msgid)
{
const char *c = strchr (msgid, '|');
if (c != NULL)
- return c + 1;
+ return c + 1;
}
-
+
return msgval;
}
/**
* g_strv_length:
* @str_array: a %NULL-terminated array of strings.
- *
- * Returns the length of the given %NULL-terminated
+ *
+ * Returns the length of the given %NULL-terminated
* string array @str_array.
- *
+ *
* Return value: length of @str_array.
*
* Since: 2.6
return i;
}
+
+
+/**
+ * g_dpgettext:
+ * @domain: the translation domain to use, or %NULL to use
+ * the domain set with textdomain()
+ * @msgctxtid: a combined message context and message id, separated
+ * by a \004 character
+ * @msgidoffset: the offset of the message id in @msgctxid
+ *
+ * This function is a variant of g_dgettext() which supports
+ * a disambiguating message context. GNU gettext uses the
+ * '\004' character to separate the message context and
+ * message id in @msgctxtid.
+ * If 0 is passed as @msgidoffset, this function will fall back to
+ * trying to use the deprecated convention of using "|" as a separation
+ * character.
+ *
+ * This uses g_dgettext() internally. See that functions for differences
+ * with dgettext() proper.
+ *
+ * Applications should normally not use this function directly,
+ * but use the C_() macro for translations with context.
+ *
+ * Returns: The translated string
+ *
+ * Since: 2.16
+ */
+const gchar *
+g_dpgettext (const gchar *domain,
+ const gchar *msgctxtid,
+ gsize msgidoffset)
+{
+ const gchar *translation;
+ gchar *sep;
+
+ translation = g_dgettext (domain, msgctxtid);
+
+ if (translation == msgctxtid)
+ {
+ if (msgidoffset > 0)
+ return msgctxtid + msgidoffset;
+
+ sep = strchr (msgctxtid, '|');
+
+ if (sep)
+ {
+ /* try with '\004' instead of '|', in case
+ * xgettext -kQ_:1g was used
+ */
+ gchar *tmp = g_alloca (strlen (msgctxtid) + 1);
+ strcpy (tmp, msgctxtid);
+ tmp[sep - msgctxtid] = '\004';
+
+ translation = g_dgettext (domain, tmp);
+
+ if (translation == tmp)
+ return sep + 1;
+ }
+ }
+
+ return translation;
+}
+
+/* This function is taken from gettext.h
+ * GNU gettext uses '\004' to separate context and msgid in .mo files.
+ */
+/**
+ * g_dpgettext2:
+ * @domain: the translation domain to use, or %NULL to use
+ * the domain set with textdomain()
+ * @context: the message context
+ * @msgid: the message
+ *
+ * This function is a variant of g_dgettext() which supports
+ * a disambiguating message context. GNU gettext uses the
+ * '\004' character to separate the message context and
+ * message id in @msgctxtid.
+ *
+ * This uses g_dgettext() internally. See that functions for differences
+ * with dgettext() proper.
+ *
+ * This function differs from C_() in that it is not a macro and
+ * thus you may use non-string-literals as context and msgid arguments.
+ *
+ * Returns: The translated string
+ *
+ * Since: 2.18
+ */
+const char *
+g_dpgettext2 (const char *domain,
+ const char *msgctxt,
+ const char *msgid)
+{
+ size_t msgctxt_len = strlen (msgctxt) + 1;
+ size_t msgid_len = strlen (msgid) + 1;
+ const char *translation;
+ char* msg_ctxt_id;
+
+ msg_ctxt_id = g_alloca (msgctxt_len + msgid_len);
+
+ memcpy (msg_ctxt_id, msgctxt, msgctxt_len - 1);
+ msg_ctxt_id[msgctxt_len - 1] = '\004';
+ memcpy (msg_ctxt_id + msgctxt_len, msgid, msgid_len);
+
+ translation = g_dgettext (domain, msg_ctxt_id);
+
+ if (translation == msg_ctxt_id)
+ {
+ /* try the old way of doing message contexts, too */
+ msg_ctxt_id[msgctxt_len - 1] = '|';
+ translation = g_dgettext (domain, msg_ctxt_id);
+
+ if (translation == msg_ctxt_id)
+ return msgid;
+ }
+
+ return translation;
+}
+
+static gboolean
+_g_dgettext_should_translate (void)
+{
+ static gsize translate = 0;
+ enum {
+ SHOULD_TRANSLATE = 1,
+ SHOULD_NOT_TRANSLATE = 2
+ };
+
+ if (G_UNLIKELY (g_once_init_enter (&translate)))
+ {
+ gboolean should_translate = TRUE;
+
+ const char *default_domain = textdomain (NULL);
+ const char *translator_comment = gettext ("");
+#ifndef G_OS_WIN32
+ const char *translate_locale = setlocale (LC_MESSAGES, NULL);
+#else
+ const char *translate_locale = g_win32_getlocale ();
+#endif
+ /* We should NOT translate only if all the following hold:
+ * - user has called textdomain() and set textdomain to non-default
+ * - default domain has no translations
+ * - locale does not start with "en_" and is not "C"
+ *
+ * Rationale:
+ * - If text domain is still the default domain, maybe user calls
+ * it later. Continue with old behavior of translating.
+ * - If locale starts with "en_", we can continue using the
+ * translations even if the app doesn't have translations for
+ * this locale. That is, en_UK and en_CA for example.
+ * - If locale is "C", maybe user calls setlocale(LC_ALL,"") later.
+ * Continue with old behavior of translating.
+ */
+ if (0 != strcmp (default_domain, "messages") &&
+ '\0' == *translator_comment &&
+ 0 != strncmp (translate_locale, "en_", 3) &&
+ 0 != strcmp (translate_locale, "C"))
+ should_translate = FALSE;
+
+ g_once_init_leave (&translate,
+ should_translate ?
+ SHOULD_TRANSLATE :
+ SHOULD_NOT_TRANSLATE);
+ }
+
+ return translate == SHOULD_TRANSLATE;
+}
+
+/**
+ * g_dgettext:
+ * @domain: the translation domain to use, or %NULL to use
+ * the domain set with textdomain()
+ * @msgid: message to translate
+ *
+ * This function is a wrapper of dgettext() which does not translate
+ * the message if the default domain as set with textdomain() has no
+ * translations for the current locale.
+ *
+ * The advantage of using this function over dgettext() proper is that
+ * libraries using this function (like GTK+) will not use translations
+ * if the application using the library does not have translations for
+ * the current locale. This results in a consistent English-only
+ * interface instead of one having partial translations. For this
+ * feature to work, the call to textdomain() and setlocale() should
+ * precede any g_dgettext() invocations. For GTK+, it means calling
+ * textdomain() before gtk_init or its variants.
+ *
+ * This function disables translations if and only if upon its first
+ * call all the following conditions hold:
+ * <itemizedlist>
+ * <listitem>@domain is not %NULL</listitem>
+ * <listitem>textdomain() has been called to set a default text domain</listitem>
+ * <listitem>there is no translations available for the default text domain
+ * and the current locale</listitem>
+ * <listitem>current locale is not "C" or any English locales (those
+ * starting with "en_")</listitem>
+ * </itemizedlist>
+ *
+ * Note that this behavior may not be desired for example if an application
+ * has its untranslated messages in a language other than English. In those
+ * cases the application should call textdomain() after initializing GTK+.
+ *
+ * Applications should normally not use this function directly,
+ * but use the _() macro for translations.
+ *
+ * Returns: The translated string
+ *
+ * Since: 2.18
+ */
+const gchar *
+g_dgettext (const gchar *domain,
+ const gchar *msgid)
+{
+ if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
+ return msgid;
+
+ return dgettext (domain, msgid);
+}
+
+/**
+ * g_dcgettext:
+ * @domain: (allow-none): the translation domain to use, or %NULL to use
+ * the domain set with textdomain()
+ * @msgid: message to translate
+ * @category: a locale category
+ *
+ * This is a variant of g_dgettext() that allows specifying a locale
+ * category instead of always using %LC_MESSAGES. See g_dgettext() for
+ * more information about how this functions differs from calling
+ * dcgettext() directly.
+ *
+ * Returns: the translated string for the given locale category
+ *
+ * Since: 2.26
+ */
+const gchar *
+g_dcgettext (const gchar *domain,
+ const gchar *msgid,
+ int category)
+{
+ if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
+ return msgid;
+
+ return dcgettext (domain, msgid, category);
+}
+
+/**
+ * g_dngettext:
+ * @domain: the translation domain to use, or %NULL to use
+ * the domain set with textdomain()
+ * @msgid: message to translate
+ * @msgid_plural: plural form of the message
+ * @n: the quantity for which translation is needed
+ *
+ * This function is a wrapper of dngettext() which does not translate
+ * the message if the default domain as set with textdomain() has no
+ * translations for the current locale.
+ *
+ * See g_dgettext() for details of how this differs from dngettext()
+ * proper.
+ *
+ * Returns: The translated string
+ *
+ * Since: 2.18
+ */
+const gchar *
+g_dngettext (const gchar *domain,
+ const gchar *msgid,
+ const gchar *msgid_plural,
+ gulong n)
+{
+ if (domain && G_UNLIKELY (!_g_dgettext_should_translate ()))
+ return n == 1 ? msgid : msgid_plural;
+
+ return dngettext (domain, msgid, msgid_plural, n);
+}