eglib/src/gstring.c

   1 /*
   2  * String functions
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@novell.com)
   6  *
   7  * (C) 2006 Novell, Inc.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining
  10  * a copy of this software and associated documentation files (the
  11  * "Software"), to deal in the Software without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27  */
  28 #define _GNU_SOURCE
  29 #include <stdio.h>
  30 #include <glib.h>
  31
  32 GString *
  33 g_string_new (const gchar *init)
  34 {
  35         GString *ret = g_new (GString, 1);
  36         int len, alloc;
  37
  38         len = strlen (init);
  39         if (len < 15)
  40                 alloc = 16;
  41         else
  42                 alloc = len+1;
  43         ret->str = g_malloc (alloc);
  44         ret->len = len;
  45         ret->allocated_len = alloc;
  46         strcpy (ret->str, init);
  47
  48         return ret;
  49 }
  50
  51 GString *
  52 g_string_new_len (const gchar *init, gsize len)
  53 {
  54         GString *ret = g_new (GString, 1);
  55
  56         ret->str = g_malloc (len+1);
  57         ret->allocated_len = len + 1;
  58         ret->len = len;
  59
  60         memcpy (ret->str, init, len);
  61         ret->str [len] = 0;
  62
  63         return ret;
  64 }
  65
  66 GString *
  67 g_string_sized_new (gsize default_size)
  68 {
  69         GString *ret = g_new (GString, 1);
  70
  71         ret->str = g_malloc (default_size);
  72         ret->str [0] = 0;
  73         ret->len = 0;
  74         ret->allocated_len = default_size;
  75
  76         return ret;
  77 }
  78
  79 gchar *
  80 g_string_free (GString *string, gboolean free_segment)
  81 {
  82         char *data;
  83         g_return_val_if_fail (string != NULL, NULL);
  84
  85         data = string->str;
  86         if (free_segment)
  87                 g_free (data);
  88         g_free (string);
  89
  90         if (free_segment)
  91                 return NULL;
  92         else
  93                 return data;
  94
  95 }
  96
  97 GString *
  98 g_string_append (GString *string, const gchar *val)
  99 {
 100         int len, size;
 101         char *new;
 102
 103         g_return_val_if_fail (string != NULL, NULL);
 104         g_return_val_if_fail (val != NULL, string);
 105
 106         len = strlen (val);
 107         if ((string->len + len) < string->allocated_len){
 108                 strcat (string->str, val);
 109                 string->len += len;
 110                 return string;
 111         }
 112         size = (len + string->len + 16) * 2;
 113         new = g_malloc (size);
 114         memcpy (new, string->str, string->len);
 115         memcpy (new + string->len, val, len);
 116         g_free (string->str);
 117         string->str = new;
 118         string->allocated_len = size;
 119         string->len += len;
 120         new [string->len] = 0;
 121
 122         return string;
 123 }
 124
 125 GString *
 126 g_string_append_c (GString *string, gchar c)
 127 {
 128         gsize size;
 129         char *new;
 130
 131         g_return_val_if_fail (string != NULL, NULL);
 132
 133         if (string->len + 1 < string->allocated_len){
 134                 string->str [string->len] = c;
 135                 string->str [string->len+1] = 0;
 136                 string->len++;
 137                 return string;
 138         }
 139         size = (string->allocated_len + 16) * 2;
 140         new = g_malloc (size);
 141         memcpy (new, string->str, string->len);
 142         new [string->len] = c;
 143         new [string->len+1] = 0;
 144
 145         g_free (string->str);
 146         string->allocated_len = size;
 147         string->len++;
 148         string->str = new;
 149
 150         return string;
 151 }
 152
 153 GString *
 154 g_string_append_len (GString *string, const gchar *val, gsize len)
 155 {
 156         int size;
 157         char *new;
 158
 159         g_return_val_if_fail (string != NULL, NULL);
 160         g_return_val_if_fail (val != NULL, string);
 161
 162         if ((string->len + len) < string->allocated_len){
 163                 memcpy (string->str+string->len, val, len);
 164                 string->len += len;
 165                 return string;
 166         }
 167         size = (len + string->len + 16) * 2;
 168         new = g_malloc (size);
 169         memcpy (new, string->str, string->len);
 170         memcpy (new + string->len, val, len);
 171         g_free (string->str);
 172         string->str = new;
 173         string->allocated_len = size;
 174         string->len += len;
 175         new [string->len] = 0;
 176
 177         return string;
 178 }
 179
 180 void
 181 g_string_append_printf (GString *string, const gchar *format, ...)
 182 {
 183         char *ret;
 184         va_list args;
 185
 186         g_return_if_fail (string != NULL);
 187         g_return_if_fail (format != NULL);
 188
 189         va_start (args, format);
 190         ret = g_strdup_vprintf (format, args);
 191         va_end (args);
 192         g_string_append (string, ret);
 193
 194         free (ret);
 195 }
 196
 197 void
 198 g_string_printf (GString *string, const gchar *format, ...)
 199 {
 200         va_list args;
 201
 202         g_return_if_fail (string != NULL);
 203         g_return_if_fail (format != NULL);
 204
 205         g_free (string->str);
 206
 207         va_start (args, format);
 208         string->str = g_strdup_vprintf (format, args);
 209         va_end (args);
 210
 211         string->len = strlen (string->str);
 212         string->allocated_len = string->len+1;
 213 }
 214
 215 GString *
 216 g_string_truncate (GString *string, gsize len)
 217 {
 218         return string;
 219 }