X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fgstring.c;h=f5890bf6424b5d39bf7f2e60277e7ca80beddcd0;hb=9f5afe3966d31ef6f1e880d950206a0325e6c777;hp=9b6aaffa5dde19dff91b62b5473abd4675b87bd5;hpb=dafdffd7516324a67db519372e9dcfddfd4fdeb0;p=platform%2Fupstream%2Fglib.git diff --git a/glib/gstring.c b/glib/gstring.c index 9b6aaff..f5890bf 100644 --- a/glib/gstring.c +++ b/glib/gstring.c @@ -12,81 +12,70 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library; if not, see . */ /* * 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/. */ -/* +/* * MT safe */ #include "config.h" -#ifdef HAVE_UNISTD_H -#include -#endif #include #include #include #include #include -#include "galias.h" -#include "glib.h" -#include "gprintf.h" - +#include "gstring.h" -struct _GStringChunk -{ - GHashTable *const_table; - GSList *storage_list; - gsize storage_next; - gsize this_size; - gsize default_size; -}; +#include "gprintf.h" -G_LOCK_DEFINE_STATIC (string_mem_chunk); -static GMemChunk *string_mem_chunk = NULL; -/* Hash Functions. +/** + * SECTION:strings + * @title: Strings + * @short_description: text buffers which grow automatically + * as text is added + * + * A #GString is an object that handles the memory management of a C + * string for you. The emphasis of #GString is on text, typically + * UTF-8. Crucially, the "str" member of a #GString is guaranteed to + * have a trailing nul character, and it is therefore always safe to + * call functions such as strchr() or g_strdup() on it. + * + * However, a #GString can also hold arbitrary binary data, because it + * has a "len" member, which includes any possible embedded nul + * characters in the data. Conceptually then, #GString is like a + * #GByteArray with the addition of many convenience methods for text, + * and a guaranteed nul terminator. */ -gboolean -g_str_equal (gconstpointer v1, - gconstpointer v2) -{ - const gchar *string1 = v1; - const gchar *string2 = v2; - - return strcmp (string1, string2) == 0; -} - -/* 31 bit hash function */ -guint -g_str_hash (gconstpointer key) -{ - const char *p = key; - guint h = *p; - - if (h) - for (p += 1; *p != '\0'; p++) - h = (h << 5) - h + *p; +/** + * GString: + * @str: points to the character data. It may move as text is added. + * The @str field is null-terminated and so + * can be used as an ordinary C string. + * @len: contains the length of the string, not including the + * terminating nul byte. + * @allocated_len: the number of bytes that can be stored in the + * string before it needs to be reallocated. May be larger than @len. + * + * The GString struct contains the public fields of a GString. + */ - return h; -} #define MY_MAXSIZE ((gsize)-1) static inline gsize -nearest_power (gsize base, gsize num) +nearest_power (gsize base, gsize num) { if (num > MY_MAXSIZE / 2) { @@ -97,141 +86,15 @@ nearest_power (gsize base, gsize num) gsize n = base; while (n < num) - n <<= 1; - - return n; - } -} - -/* String Chunks. - */ - -GStringChunk* -g_string_chunk_new (gsize default_size) -{ - GStringChunk *new_chunk = g_new (GStringChunk, 1); - gsize size = 1; - - size = nearest_power (1, default_size); - - new_chunk->const_table = NULL; - new_chunk->storage_list = NULL; - new_chunk->storage_next = size; - new_chunk->default_size = size; - new_chunk->this_size = size; - - return new_chunk; -} - -void -g_string_chunk_free (GStringChunk *chunk) -{ - GSList *tmp_list; + n <<= 1; - g_return_if_fail (chunk != NULL); - - if (chunk->storage_list) - { - for (tmp_list = chunk->storage_list; tmp_list; tmp_list = tmp_list->next) - g_free (tmp_list->data); - - g_slist_free (chunk->storage_list); - } - - if (chunk->const_table) - g_hash_table_destroy (chunk->const_table); - - g_free (chunk); -} - -gchar* -g_string_chunk_insert (GStringChunk *chunk, - const gchar *string) -{ - g_return_val_if_fail (chunk != NULL, NULL); - - return g_string_chunk_insert_len (chunk, string, -1); -} - -gchar* -g_string_chunk_insert_const (GStringChunk *chunk, - const gchar *string) -{ - char* lookup; - - g_return_val_if_fail (chunk != NULL, NULL); - - if (!chunk->const_table) - chunk->const_table = g_hash_table_new (g_str_hash, g_str_equal); - - lookup = (char*) g_hash_table_lookup (chunk->const_table, (gchar *)string); - - if (!lookup) - { - lookup = g_string_chunk_insert (chunk, string); - g_hash_table_insert (chunk->const_table, lookup, lookup); + return n; } - - return lookup; } -/** - * g_string_chunk_insert_len: - * @chunk: a #GStringChunk - * @string: bytes to insert - * @len: number of bytes of @string to insert, or -1 to insert a - * nul-terminated string. - * - * Adds a copy of the first @len bytes of @string to the #GStringChunk. The - * copy is nul-terminated. - * - * The characters in the string can be changed, if necessary, though you - * should not change anything after the end of the string. - * - * Return value: a pointer to the copy of @string within the #GStringChunk - * - * Since: 2.4 - **/ -gchar* -g_string_chunk_insert_len (GStringChunk *chunk, - const gchar *string, - gssize len) -{ - gchar* pos; - - g_return_val_if_fail (chunk != NULL, NULL); - - if (len < 0) - len = strlen (string); - - if ((chunk->storage_next + len + 1) > chunk->this_size) - { - gsize new_size = nearest_power (chunk->default_size, len + 1); - - chunk->storage_list = g_slist_prepend (chunk->storage_list, - g_new (gchar, new_size)); - - chunk->this_size = new_size; - chunk->storage_next = 0; - } - - pos = ((gchar *) chunk->storage_list->data) + chunk->storage_next; - - *(pos + len) = '\0'; - - strncpy (pos, string, len); - len = strlen (pos); - - chunk->storage_next += len + 1; - - return pos; -} - -/* Strings. - */ static void -g_string_maybe_expand (GString* string, - gsize len) +g_string_maybe_expand (GString *string, + gsize len) { if (string->len + len >= string->allocated_len) { @@ -240,19 +103,22 @@ g_string_maybe_expand (GString* string, } } -GString* -g_string_sized_new (gsize dfl_size) +/** + * g_string_sized_new: + * @dfl_size: the default size of the space allocated to + * hold the string + * + * Creates a new #GString, with enough space for @dfl_size + * bytes. This is useful if you are going to add a lot of + * text to the string and don't want it to be reallocated + * too often. + * + * Returns: the new #GString + */ +GString * +g_string_sized_new (gsize dfl_size) { - GString *string; - - G_LOCK (string_mem_chunk); - if (!string_mem_chunk) - string_mem_chunk = g_mem_chunk_new ("string mem chunk", - sizeof (GString), - 1024, G_ALLOC_AND_FREE); - - string = g_chunk_new (GString, string_mem_chunk); - G_UNLOCK (string_mem_chunk); + GString *string = g_slice_new (GString); string->allocated_len = 0; string->len = 0; @@ -264,14 +130,23 @@ g_string_sized_new (gsize dfl_size) return string; } -GString* +/** + * g_string_new: + * @init: (allow-none): the initial text to copy into the string, or %NULL to + * start with an empty string. + * + * Creates a new #GString, initialized with the given string. + * + * Returns: the new #GString + */ +GString * g_string_new (const gchar *init) { GString *string; if (init == NULL || *init == '\0') string = g_string_sized_new (2); - else + else { gint len; @@ -284,9 +159,24 @@ g_string_new (const gchar *init) return string; } -GString* +/** + * g_string_new_len: + * @init: initial contents of the string + * @len: length of @init to use + * + * Creates a new #GString with @len bytes of the @init buffer. + * Because a length is provided, @init need not be nul-terminated, + * and can contain embedded nul bytes. + * + * Since this function does not stop at nul bytes, it is the caller's + * responsibility to ensure that @init has at least @len addressable + * bytes. + * + * Returns: a new #GString + */ +GString * g_string_new_len (const gchar *init, - gssize len) + gssize len) { GString *string; @@ -295,17 +185,30 @@ g_string_new_len (const gchar *init, else { string = g_string_sized_new (len); - + if (init) g_string_append_len (string, init, len); - + return string; } } -gchar* -g_string_free (GString *string, - gboolean free_segment) +/** + * g_string_free: + * @string: a #GString + * @free_segment: if %TRUE, the actual character data is freed as well + * + * Frees the memory allocated for the #GString. + * If @free_segment is %TRUE it also frees the character data. If + * it's %FALSE, the caller gains ownership of the buffer and must + * free it after use with g_free(). + * + * Returns: the character data of @string + * (i.e. %NULL if @free_segment is %TRUE) + */ +gchar * +g_string_free (GString *string, + gboolean free_segment) { gchar *segment; @@ -319,13 +222,53 @@ g_string_free (GString *string, else segment = string->str; - G_LOCK (string_mem_chunk); - g_mem_chunk_free (string_mem_chunk, string); - G_UNLOCK (string_mem_chunk); + g_slice_free (GString, string); return segment; } +/** + * g_string_free_to_bytes: + * @string: (transfer full): a #GString + * + * Transfers ownership of the contents of @string to a newly allocated + * #GBytes. The #GString structure itself is deallocated, and it is + * therefore invalid to use @string after invoking this function. + * + * Note that while #GString ensures that its buffer always has a + * trailing nul character (not reflected in its "len"), the returned + * #GBytes does not include this extra nul; i.e. it has length exactly + * equal to the "len" member. + * + * Returns: A newly allocated #GBytes containing contents of @string; @string itself is freed + * Since: 2.34 + */ +GBytes* +g_string_free_to_bytes (GString *string) +{ + gsize len; + gchar *buf; + + g_return_val_if_fail (string != NULL, NULL); + + len = string->len; + + buf = g_string_free (string, FALSE); + + return g_bytes_new_take (buf, len); +} + +/** + * g_string_equal: + * @v: a #GString + * @v2: another #GString + * + * Compares two strings for equality, returning %TRUE if they are equal. + * For use with #GHashTable. + * + * Returns: %TRUE if the strings are the same length and contain the + * same bytes + */ gboolean g_string_equal (const GString *v, const GString *v2) @@ -333,7 +276,7 @@ g_string_equal (const GString *v, gchar *p, *q; GString *string1 = (GString *) v; GString *string2 = (GString *) v2; - gsize i = string1->len; + gsize i = string1->len; if (i != string2->len) return FALSE; @@ -343,7 +286,7 @@ g_string_equal (const GString *v, while (i) { if (*p != *q) - return FALSE; + return FALSE; p++; q++; i--; @@ -351,14 +294,22 @@ g_string_equal (const GString *v, return TRUE; } -/* 31 bit hash function */ +/** + * g_string_hash: + * @str: a string to hash + * + * Creates a hash code for @str; for use with #GHashTable. + * + * Returns: hash code for @str + */ guint g_string_hash (const GString *str) { const gchar *p = str->str; - gsize n = str->len; + gsize n = str->len; guint h = 0; + /* 31 bit hash function */ while (n--) { h = (h << 5) - h + *p; @@ -368,18 +319,32 @@ g_string_hash (const GString *str) return h; } -GString* +/** + * g_string_assign: + * @string: the destination #GString. Its current contents + * are destroyed. + * @rval: the string to copy into @string + * + * Copies the bytes from a string into a #GString, + * destroying any previous contents. It is rather like + * the standard strcpy() function, except that you do not + * have to worry about having enough space to copy the string. + * + * Returns: @string + */ +GString * g_string_assign (GString *string, - const gchar *rval) + const gchar *rval) { g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (rval != NULL, string); - /* Make sure assigning to itself doesn't corrupt the string. */ + /* Make sure assigning to itself doesn't corrupt the string. */ if (string->str != rval) { - /* Assigning from substring should be ok since g_string_truncate - does not realloc. */ + /* Assigning from substring should be ok, since + * g_string_truncate() does not reallocate. + */ g_string_truncate (string, 0); g_string_append (string, rval); } @@ -387,9 +352,18 @@ g_string_assign (GString *string, return string; } -GString* +/** + * g_string_truncate: + * @string: a #GString + * @len: the new size of @string + * + * Cuts off the end of the GString, leaving the first @len bytes. + * + * Returns: @string + */ +GString * g_string_truncate (GString *string, - gsize len) + gsize len) { g_return_val_if_fail (string != NULL, NULL); @@ -403,38 +377,60 @@ g_string_truncate (GString *string, * g_string_set_size: * @string: a #GString * @len: the new length - * + * * Sets the length of a #GString. If the length is less than * the current length, the string will be truncated. If the * length is greater than the current length, the contents * of the newly added area are undefined. (However, as - * always, string->str[string->len] will be a nul byte.) - * - * Return value: @string - **/ -GString* + * always, string->str[string->len] will be a nul byte.) + * + * Returns: @string + */ +GString * g_string_set_size (GString *string, - gsize len) + gsize len) { g_return_val_if_fail (string != NULL, NULL); if (len >= string->allocated_len) g_string_maybe_expand (string, len - string->len); - + string->len = len; string->str[len] = 0; return string; } -GString* +/** + * g_string_insert_len: + * @string: a #GString + * @pos: position in @string where insertion should + * happen, or -1 for at the end + * @val: bytes to insert + * @len: number of bytes of @val to insert + * + * Inserts @len bytes of @val into @string at @pos. + * Because @len is provided, @val may contain embedded + * nuls and need not be nul-terminated. If @pos is -1, + * bytes are inserted at the end of the string. + * + * Since this function does not stop at nul bytes, it is + * the caller's responsibility to ensure that @val has at + * least @len addressable bytes. + * + * Returns: @string + */ +GString * g_string_insert_len (GString *string, - gssize pos, - const gchar *val, - gssize len) + gssize pos, + const gchar *val, + gssize len) { g_return_val_if_fail (string != NULL, NULL); - g_return_val_if_fail (val != NULL, string); + g_return_val_if_fail (len == 0 || val != NULL, string); + + if (len == 0) + return string; if (len < 0) len = strlen (val); @@ -444,10 +440,11 @@ g_string_insert_len (GString *string, else g_return_val_if_fail (pos <= string->len, string); - /* Check whether val represents a substring of string. This test - probably violates chapter and verse of the C standards, since - ">=" and "<=" are only valid when val really is a substring. - In practice, it will work on modern archs. */ + /* Check whether val represents a substring of string. + * This test probably violates chapter and verse of the C standards, + * since ">=" and "<=" are only valid when val really is a substring. + * In practice, it will work on modern archs. + */ if (val >= string->str && val <= string->str + string->len) { gsize offset = val - string->str; @@ -459,20 +456,20 @@ g_string_insert_len (GString *string, /* Open up space where we are going to insert. */ if (pos < string->len) - g_memmove (string->str + pos + len, string->str + pos, string->len - pos); + memmove (string->str + pos + len, string->str + pos, string->len - pos); /* Move the source part before the gap, if any. */ if (offset < pos) - { - precount = MIN (len, pos - offset); - memcpy (string->str + pos, val, precount); - } + { + precount = MIN (len, pos - offset); + memcpy (string->str + pos, val, precount); + } /* Move the source part after the gap, if any. */ if (len > precount) - memcpy (string->str + pos + precount, - val + /* Already moved: */ precount + /* Space opened up: */ len, - len - precount); + memcpy (string->str + pos + precount, + val + /* Already moved: */ precount + /* Space opened up: */ len, + len - precount); } else { @@ -482,10 +479,13 @@ g_string_insert_len (GString *string, * of the old string to the end, opening up space */ if (pos < string->len) - g_memmove (string->str + pos + len, string->str + pos, string->len - pos); + memmove (string->str + pos + len, string->str + pos, string->len - pos); /* insert the new string */ - memcpy (string->str + pos, val, len); + if (len == 1) + string->str[pos] = *val; + else + memcpy (string->str + pos, val, len); } string->len += len; @@ -495,31 +495,151 @@ g_string_insert_len (GString *string, return string; } -GString* +#define SUB_DELIM_CHARS "!$&'()*+,;=" + +static gboolean +is_valid (char c, + const char *reserved_chars_allowed) +{ + if (g_ascii_isalnum (c) || + c == '-' || + c == '.' || + c == '_' || + c == '~') + return TRUE; + + if (reserved_chars_allowed && + strchr (reserved_chars_allowed, c) != NULL) + return TRUE; + + return FALSE; +} + +static gboolean +gunichar_ok (gunichar c) +{ + return + (c != (gunichar) -2) && + (c != (gunichar) -1); +} + +/** + * g_string_append_uri_escaped: + * @string: a #GString + * @unescaped: a string + * @reserved_chars_allowed: a string of reserved characters allowed + * to be used, or %NULL + * @allow_utf8: set %TRUE if the escaped string may include UTF8 characters + * + * Appends @unescaped to @string, escaped any characters that + * are reserved in URIs using URI-style escape sequences. + * + * Returns: @string + * + * Since: 2.16 + */ +GString * +g_string_append_uri_escaped (GString *string, + const gchar *unescaped, + const gchar *reserved_chars_allowed, + gboolean allow_utf8) +{ + unsigned char c; + const gchar *end; + static const gchar hex[16] = "0123456789ABCDEF"; + + g_return_val_if_fail (string != NULL, NULL); + g_return_val_if_fail (unescaped != NULL, NULL); + + end = unescaped + strlen (unescaped); + + while ((c = *unescaped) != 0) + { + if (c >= 0x80 && allow_utf8 && + gunichar_ok (g_utf8_get_char_validated (unescaped, end - unescaped))) + { + int len = g_utf8_skip [c]; + g_string_append_len (string, unescaped, len); + unescaped += len; + } + else if (is_valid (c, reserved_chars_allowed)) + { + g_string_append_c (string, c); + unescaped++; + } + else + { + g_string_append_c (string, '%'); + g_string_append_c (string, hex[((guchar)c) >> 4]); + g_string_append_c (string, hex[((guchar)c) & 0xf]); + unescaped++; + } + } + + return string; +} + +/** + * g_string_append: + * @string: a #GString + * @val: the string to append onto the end of @string + * + * Adds a string onto the end of a #GString, expanding + * it if necessary. + * + * Returns: @string + */ +GString * g_string_append (GString *string, - const gchar *val) -{ + const gchar *val) +{ g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (val != NULL, string); return g_string_insert_len (string, -1, val, -1); } -GString* -g_string_append_len (GString *string, +/** + * g_string_append_len: + * @string: a #GString + * @val: bytes to append + * @len: number of bytes of @val to use + * + * Appends @len bytes of @val to @string. Because @len is + * provided, @val may contain embedded nuls and need not + * be nul-terminated. + * + * Since this function does not stop at nul bytes, it is + * the caller's responsibility to ensure that @val has at + * least @len addressable bytes. + * + * Returns: @string + */ +GString * +g_string_append_len (GString *string, const gchar *val, - gssize len) + gssize len) { g_return_val_if_fail (string != NULL, NULL); - g_return_val_if_fail (val != NULL, string); + g_return_val_if_fail (len == 0 || val != NULL, string); return g_string_insert_len (string, -1, val, len); } +/** + * g_string_append_c: + * @string: a #GString + * @c: the byte to append onto the end of @string + * + * Adds a byte onto the end of a #GString, expanding + * it if necessary. + * + * Returns: @string + */ #undef g_string_append_c -GString* +GString * g_string_append_c (GString *string, - gchar c) + gchar c) { g_return_val_if_fail (string != NULL, NULL); @@ -530,35 +650,61 @@ g_string_append_c (GString *string, * g_string_append_unichar: * @string: a #GString * @wc: a Unicode character - * + * * Converts a Unicode character into UTF-8, and appends it * to the string. - * - * Return value: @string - **/ -GString* + * + * Returns: @string + */ +GString * g_string_append_unichar (GString *string, - gunichar wc) -{ + gunichar wc) +{ g_return_val_if_fail (string != NULL, NULL); - + return g_string_insert_unichar (string, -1, wc); } -GString* +/** + * g_string_prepend: + * @string: a #GString + * @val: the string to prepend on the start of @string + * + * Adds a string on to the start of a #GString, + * expanding it if necessary. + * + * Returns: @string + */ +GString * g_string_prepend (GString *string, - const gchar *val) + const gchar *val) { g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (val != NULL, string); - + return g_string_insert_len (string, 0, val, -1); } -GString* -g_string_prepend_len (GString *string, +/** + * g_string_prepend_len: + * @string: a #GString + * @val: bytes to prepend + * @len: number of bytes in @val to prepend + * + * Prepends @len bytes of @val to @string. + * Because @len is provided, @val may contain + * embedded nuls and need not be nul-terminated. + * + * Since this function does not stop at nul bytes, + * it is the caller's responsibility to ensure that + * @val has at least @len addressable bytes. + * + * Returns: @string + */ +GString * +g_string_prepend_len (GString *string, const gchar *val, - gssize len) + gssize len) { g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (val != NULL, string); @@ -566,51 +712,83 @@ g_string_prepend_len (GString *string, return g_string_insert_len (string, 0, val, len); } -GString* +/** + * g_string_prepend_c: + * @string: a #GString + * @c: the byte to prepend on the start of the #GString + * + * Adds a byte onto the start of a #GString, + * expanding it if necessary. + * + * Returns: @string + */ +GString * g_string_prepend_c (GString *string, - gchar c) -{ + gchar c) +{ g_return_val_if_fail (string != NULL, NULL); - + return g_string_insert_c (string, 0, c); } /** * g_string_prepend_unichar: - * @string: a #GString. - * @wc: a Unicode character. - * + * @string: a #GString + * @wc: a Unicode character + * * Converts a Unicode character into UTF-8, and prepends it * to the string. - * - * Return value: @string. - **/ -GString* + * + * Returns: @string + */ +GString * g_string_prepend_unichar (GString *string, - gunichar wc) -{ + gunichar wc) +{ g_return_val_if_fail (string != NULL, NULL); - + return g_string_insert_unichar (string, 0, wc); } -GString* +/** + * g_string_insert: + * @string: a #GString + * @pos: the position to insert the copy of the string + * @val: the string to insert + * + * Inserts a copy of a string into a #GString, + * expanding it if necessary. + * + * Returns: @string + */ +GString * g_string_insert (GString *string, - gssize pos, - const gchar *val) + gssize pos, + const gchar *val) { g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (val != NULL, string); + if (pos >= 0) g_return_val_if_fail (pos <= string->len, string); - + return g_string_insert_len (string, pos, val, -1); } -GString* +/** + * g_string_insert_c: + * @string: a #GString + * @pos: the position to insert the byte + * @c: the byte to insert + * + * Inserts a byte into a #GString, expanding it if necessary. + * + * Returns: @string + */ +GString * g_string_insert_c (GString *string, - gssize pos, - gchar c) + gssize pos, + gchar c) { g_return_val_if_fail (string != NULL, NULL); @@ -620,10 +798,10 @@ g_string_insert_c (GString *string, pos = string->len; else g_return_val_if_fail (pos <= string->len, string); - + /* If not just an append, move the old stuff */ if (pos < string->len) - g_memmove (string->str + pos + 1, string->str + pos, string->len - pos); + memmove (string->str + pos + 1, string->str + pos, string->len - pos); string->str[pos] = c; @@ -637,37 +815,172 @@ g_string_insert_c (GString *string, /** * g_string_insert_unichar: * @string: a #GString - * @pos: the position at which to insert character, or -1 to - * append at the end of the string. + * @pos: the position at which to insert character, or -1 + * to append at the end of the string * @wc: a Unicode character - * + * * Converts a Unicode character into UTF-8, and insert it * into the string at the given position. - * - * Return value: @string - **/ -GString* -g_string_insert_unichar (GString *string, - gssize pos, - gunichar wc) -{ - gchar buf[6]; - gint charlen; - - /* We could be somewhat more efficient here by computing - * the length, adding the space, then converting into that - * space, by cut-and-pasting the internals of g_unichar_to_utf8. - */ + * + * Returns: @string + */ +GString * +g_string_insert_unichar (GString *string, + gssize pos, + gunichar wc) +{ + gint charlen, first, i; + gchar *dest; + + g_return_val_if_fail (string != NULL, NULL); + + /* Code copied from g_unichar_to_utf() */ + if (wc < 0x80) + { + first = 0; + charlen = 1; + } + else if (wc < 0x800) + { + first = 0xc0; + charlen = 2; + } + else if (wc < 0x10000) + { + first = 0xe0; + charlen = 3; + } + else if (wc < 0x200000) + { + first = 0xf0; + charlen = 4; + } + else if (wc < 0x4000000) + { + first = 0xf8; + charlen = 5; + } + else + { + first = 0xfc; + charlen = 6; + } + /* End of copied code */ + + g_string_maybe_expand (string, charlen); + + if (pos < 0) + pos = string->len; + else + g_return_val_if_fail (pos <= string->len, string); + + /* If not just an append, move the old stuff */ + if (pos < string->len) + memmove (string->str + pos + charlen, string->str + pos, string->len - pos); + + dest = string->str + pos; + /* Code copied from g_unichar_to_utf() */ + for (i = charlen - 1; i > 0; --i) + { + dest[i] = (wc & 0x3f) | 0x80; + wc >>= 6; + } + dest[0] = wc | first; + /* End of copied code */ + + string->len += charlen; + + string->str[string->len] = 0; + + return string; +} + +/** + * g_string_overwrite: + * @string: a #GString + * @pos: the position at which to start overwriting + * @val: the string that will overwrite the @string starting at @pos + * + * Overwrites part of a string, lengthening it if necessary. + * + * Returns: @string + * + * Since: 2.14 + */ +GString * +g_string_overwrite (GString *string, + gsize pos, + const gchar *val) +{ + g_return_val_if_fail (val != NULL, string); + return g_string_overwrite_len (string, pos, val, strlen (val)); +} + +/** + * g_string_overwrite_len: + * @string: a #GString + * @pos: the position at which to start overwriting + * @val: the string that will overwrite the @string starting at @pos + * @len: the number of bytes to write from @val + * + * Overwrites part of a string, lengthening it if necessary. + * This function will work with embedded nuls. + * + * Returns: @string + * + * Since: 2.14 + */ +GString * +g_string_overwrite_len (GString *string, + gsize pos, + const gchar *val, + gssize len) +{ + gsize end; + g_return_val_if_fail (string != NULL, NULL); - charlen = g_unichar_to_utf8 (wc, buf); - return g_string_insert_len (string, pos, buf, charlen); + if (!len) + return string; + + g_return_val_if_fail (val != NULL, string); + g_return_val_if_fail (pos <= string->len, string); + + if (len < 0) + len = strlen (val); + + end = pos + len; + + if (end > string->len) + g_string_maybe_expand (string, end - string->len); + + memcpy (string->str + pos, val, len); + + if (end > string->len) + { + string->str[end] = '\0'; + string->len = end; + } + + return string; } -GString* +/** + * g_string_erase: + * @string: a #GString + * @pos: the position of the content to remove + * @len: the number of bytes to remove, or -1 to remove all + * following bytes + * + * Removes @len bytes from a #GString, starting at position @pos. + * The rest of the #GString is shifted down to fill the gap. + * + * Returns: @string + */ +GString * g_string_erase (GString *string, - gssize pos, - gssize len) + gssize pos, + gssize len) { g_return_val_if_fail (string != NULL, NULL); g_return_val_if_fail (pos >= 0, string); @@ -680,11 +993,11 @@ g_string_erase (GString *string, g_return_val_if_fail (pos + len <= string->len, string); if (pos + len < string->len) - g_memmove (string->str + pos, string->str + pos + len, string->len - (pos + len)); + memmove (string->str + pos, string->str + pos + len, string->len - (pos + len)); } string->len -= len; - + string->str[string->len] = 0; return string; @@ -693,14 +1006,14 @@ g_string_erase (GString *string, /** * g_string_ascii_down: * @string: a GString - * - * Converts all upper case ASCII letters to lower case ASCII letters. - * - * Return value: passed-in @string pointer, with all the upper case - * characters converted to lower case in place, with - * semantics that exactly match g_ascii_tolower. - **/ -GString* + * + * Converts all uppercase ASCII letters to lowercase ASCII letters. + * + * Returns: passed-in @string pointer, with all the + * uppercase characters converted to lowercase in place, + * with semantics that exactly match g_ascii_tolower(). + */ +GString * g_string_ascii_down (GString *string) { gchar *s; @@ -724,14 +1037,14 @@ g_string_ascii_down (GString *string) /** * g_string_ascii_up: * @string: a GString - * - * Converts all lower case ASCII letters to upper case ASCII letters. - * - * Return value: passed-in @string pointer, with all the lower case - * characters converted to upper case in place, with - * semantics that exactly match g_ascii_toupper. - **/ -GString* + * + * Converts all lowercase ASCII letters to uppercase ASCII letters. + * + * Returns: passed-in @string pointer, with all the + * lowercase characters converted to uppercase in place, + * with semantics that exactly match g_ascii_toupper(). + */ +GString * g_string_ascii_up (GString *string) { gchar *s; @@ -755,16 +1068,16 @@ g_string_ascii_up (GString *string) /** * g_string_down: * @string: a #GString - * + * * Converts a #GString to lowercase. * - * Returns: the #GString. + * Returns: the #GString * - * Deprecated: This function uses the locale-specific tolower() function, - * which is almost never the right thing. Use g_string_ascii_down() or - * g_utf8_strdown() instead. + * Deprecated:2.2: This function uses the locale-specific + * tolower() function, which is almost never the right thing. + * Use g_string_ascii_down() or g_utf8_strdown() instead. */ -GString* +GString * g_string_down (GString *string) { guchar *s; @@ -772,13 +1085,13 @@ g_string_down (GString *string) g_return_val_if_fail (string != NULL, NULL); - n = string->len; + n = string->len; s = (guchar *) string->str; while (n) { if (isupper (*s)) - *s = tolower (*s); + *s = tolower (*s); s++; n--; } @@ -788,17 +1101,17 @@ g_string_down (GString *string) /** * g_string_up: - * @string: a #GString - * + * @string: a #GString + * * Converts a #GString to uppercase. - * - * Return value: the #GString - * - * Deprecated: This function uses the locale-specific toupper() function, - * which is almost never the right thing. Use g_string_ascii_up() or - * g_utf8_strup() instead. - **/ -GString* + * + * Returns: @string + * + * Deprecated:2.2: This function uses the locale-specific + * toupper() function, which is almost never the right thing. + * Use g_string_ascii_up() or g_utf8_strup() instead. + */ +GString * g_string_up (GString *string) { guchar *s; @@ -812,7 +1125,7 @@ g_string_up (GString *string) while (n) { if (islower (*s)) - *s = toupper (*s); + *s = toupper (*s); s++; n--; } @@ -820,41 +1133,134 @@ g_string_up (GString *string) return string; } -static void -g_string_append_printf_internal (GString *string, - const gchar *fmt, - va_list args) +/** + * g_string_append_vprintf: + * @string: a #GString + * @format: the string format. See the printf() documentation + * @args: the list of arguments to insert in the output + * + * Appends a formatted string onto the end of a #GString. + * This function is similar to g_string_append_printf() + * except that the arguments to the format string are passed + * as a va_list. + * + * Since: 2.14 + */ +void +g_string_append_vprintf (GString *string, + const gchar *format, + va_list args) { - gchar *buffer; - gint length; - - length = g_vasprintf (&buffer, fmt, args); - g_string_append_len (string, buffer, length); - g_free (buffer); + gchar *buf; + gint len; + + g_return_if_fail (string != NULL); + g_return_if_fail (format != NULL); + + len = g_vasprintf (&buf, format, args); + + if (len >= 0) + { + g_string_maybe_expand (string, len); + memcpy (string->str + string->len, buf, len + 1); + string->len += len; + g_free (buf); + } } +/** + * g_string_vprintf: + * @string: a #GString + * @format: the string format. See the printf() documentation + * @args: the parameters to insert into the format string + * + * Writes a formatted string into a #GString. + * This function is similar to g_string_printf() except that + * the arguments to the format string are passed as a va_list. + * + * Since: 2.14 + */ void -g_string_printf (GString *string, - const gchar *fmt, - ...) +g_string_vprintf (GString *string, + const gchar *format, + va_list args) +{ + g_string_truncate (string, 0); + g_string_append_vprintf (string, format, args); +} + +/** + * g_string_sprintf: + * @string: a #GString + * @format: the string format. See the sprintf() documentation + * @...: the parameters to insert into the format string + * + * Writes a formatted string into a #GString. + * This is similar to the standard sprintf() function, + * except that the #GString buffer automatically expands + * to contain the results. The previous contents of the + * #GString are destroyed. + * + * Deprecated: This function has been renamed to g_string_printf(). + */ + +/** + * g_string_printf: + * @string: a #GString + * @format: the string format. See the printf() documentation + * @...: the parameters to insert into the format string + * + * Writes a formatted string into a #GString. + * This is similar to the standard sprintf() function, + * except that the #GString buffer automatically expands + * to contain the results. The previous contents of the + * #GString are destroyed. + */ +void +g_string_printf (GString *string, + const gchar *format, + ...) { va_list args; g_string_truncate (string, 0); - va_start (args, fmt); - g_string_append_printf_internal (string, fmt, args); + va_start (args, format); + g_string_append_vprintf (string, format, args); va_end (args); } +/** + * g_string_sprintfa: + * @string: a #GString + * @format: the string format. See the sprintf() documentation + * @...: the parameters to insert into the format string + * + * Appends a formatted string onto the end of a #GString. + * This function is similar to g_string_sprintf() except that + * the text is appended to the #GString. + * + * Deprecated: This function has been renamed to g_string_append_printf() + */ + +/** + * g_string_append_printf: + * @string: a #GString + * @format: the string format. See the printf() documentation + * @...: the parameters to insert into the format string + * + * Appends a formatted string onto the end of a #GString. + * This function is similar to g_string_printf() except + * that the text is appended to the #GString. + */ void -g_string_append_printf (GString *string, - const gchar *fmt, - ...) +g_string_append_printf (GString *string, + const gchar *format, + ...) { va_list args; - va_start (args, fmt); - g_string_append_printf_internal (string, fmt, args); + va_start (args, format); + g_string_append_vprintf (string, format, args); va_end (args); }