source/lib/ustring.c

   1 /*
   2    Dynamic Unicode Strings
   3    Copyright (C) Elrond                            2000
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include "includes.h"
  21 #include "ustring.h"
  22
  23 #define g_free(x) safe_free(x)
  24
  25
  26 #define INITIAL_SIZE 32
  27
  28
  29 UString *ustring_new(const char *init)
  30 {
  31         UString *str;
  32
  33         str = g_new(UString, 1);
  34         if (str == NULL)
  35         {
  36                 return str;
  37         }
  38         str->len = 0;
  39         str->alloc = INITIAL_SIZE;
  40         str->str = g_new(uint16, str->alloc);
  41         if(str->str == NULL)
  42         {
  43                 g_free(str);
  44                 return NULL;
  45         }
  46         str->str[0] = 0;
  47
  48         if (init)
  49         {
  50                 ustring_assign_ascii_str(str, init);
  51         }
  52
  53         return str;
  54 }
  55
  56 void ustring_free(UString *str)
  57 {
  58         if (! str)
  59         {
  60                 return;
  61         }
  62         g_free(str->str);
  63         g_free(str);
  64 }
  65
  66 static size_t nearest_pow(size_t n)
  67 {
  68         size_t i = 1;
  69         while (i < n)
  70         {
  71                 i *= 2;
  72         }
  73         return i;
  74 }
  75
  76 UString *ustring_grow(UString *str, size_t new_alloc)
  77 {
  78         if(! str)
  79         {
  80                 return str;
  81         }
  82         if(str->alloc >= new_alloc)
  83         {
  84                 return str;
  85         }
  86         new_alloc = nearest_pow(new_alloc);
  87         str->str = g_renew(uint16, str->str, new_alloc);
  88         if (str->str == NULL)
  89         {
  90                 new_alloc = 0;
  91                 str->len = 0;
  92         }
  93         str->alloc = new_alloc;
  94         return str;
  95 }
  96
  97 UString *ustring_shrink(UString *str)
  98 {
  99         size_t new_alloc;
 100
 101         if(! str)
 102         {
 103                 return str;
 104         }
 105         new_alloc = str->len + 1;
 106         if (new_alloc == str->alloc)
 107         {
 108                 return str;
 109         }
 110
 111         str->str = g_renew(uint16, str->str, new_alloc);
 112         str->alloc = new_alloc;
 113         return str;
 114 }
 115
 116 UString *ustring_assign(UString *str, const uint16 *src, size_t len)
 117 {
 118         if (! str)
 119         {
 120                 return str;
 121         }
 122         if ((src == NULL) || (len == 0))
 123         {
 124                 str->len = 0;
 125                 str->str[0] = 0;
 126         }
 127
 128         ustring_grow(str, len+1);
 129
 130         memcpy(str->str, src, len*sizeof(uint16));
 131
 132         str->str[len] = 0;
 133         str->len = len;
 134
 135         return str;
 136 }
 137
 138 UString *ustring_assign_ascii(UString *str, const char *src, size_t len)
 139 {
 140         uint16 *dest;
 141
 142         if (! str)
 143         {
 144                 return str;
 145         }
 146         if ((src == NULL) || (len == 0))
 147         {
 148                 str->len = 0;
 149                 str->str[0] = 0;
 150                 return str;
 151         }
 152         ustring_grow(str, len+1);
 153
 154         str->len = len;
 155
 156         dest = str->str;
 157
 158         while (len > 0)
 159         {
 160                 char c = *src++;
 161                 *dest++ = c;
 162                 len--;
 163         }
 164
 165         *dest = 0;
 166
 167         return str;
 168 }
 169
 170 UString *ustring_assign_ascii_str(UString *str, const char *src)
 171 {
 172         return ustring_assign_ascii(str, src, (src ? strlen(src) : 0));
 173 }
 174
 175 UString *ustring_dup(const UString *str)
 176 {
 177         UString *new;
 178
 179         if (! str)
 180         {
 181                 return str;
 182         }
 183         new = ustring_new(NULL);
 184         if (! new)
 185         {
 186                 return new;
 187         }
 188
 189         ustring_assign(new, str->str, str->len);
 190
 191         return new;
 192 }
 193
 194 int ustring_compare(const UString *a, const UString *b)
 195 {
 196         uint16 *pa, *pb;
 197         int ca, cb;
 198         size_t len;
 199
 200         if (a == b) return 0;
 201         if (!a) return 1;
 202         if (!b) return -1;
 203
 204         pa = a->str;
 205         pb = b->str;
 206         len = MIN(a->len, b->len) + 1; /* include the final NUL */
 207
 208         while ((len > 0) && (*pa == *pb))
 209         {
 210                 pa++;
 211                 pb++;
 212                 len--;
 213         }
 214         if (len == 0)
 215         {
 216                 if (a->len == b->len) return 0;
 217                 if (a->len <  b->len) return 1;
 218                 return 1;
 219         }
 220
 221         ca = *pa;
 222         cb = *pb;
 223
 224         return cb - ca;
 225 }
 226
 227 int ustring_compare_case(const UString *a, const UString *b)
 228 {
 229         uint16 *pa, *pb;
 230         int ca, cb;
 231         size_t len;
 232
 233         if (a == b) return 0;
 234         if (!a) return 1;
 235         if (!b) return -1;
 236
 237         pa = a->str;
 238         pb = b->str;
 239         len = MIN(a->len, b->len) + 1; /* include the final NUL */
 240
 241         while ((len > 0) && (toupper(*pa) == toupper(*pb)))
 242         {
 243                 pa++;
 244                 pb++;
 245                 len--;
 246         }
 247         if (len == 0)
 248         {
 249                 if (a->len == b->len) return 0;
 250                 if (a->len <  b->len) return 1;
 251                 return 1;
 252         }
 253
 254         ca = toupper(*pa);
 255         cb = toupper(*pb);
 256
 257         return cb - ca;
 258 }
 259
 260 UString *ustring_append_c(UString *str, uint16 c)
 261 {
 262         if (! str)
 263         {
 264                 return str;
 265         }
 266         ustring_grow(str, str->len + 2);
 267         str->str[str->len] = c;
 268         str->len++;
 269         str->str[str->len] = 0;
 270
 271         return str;
 272 }
 273
 274 UString *ustring_sync_len(UString *str)
 275 {
 276         uint16 *p, *a;
 277
 278         if (! str)
 279         {
 280                 return str;
 281         }
 282
 283         a = str->str;
 284         p = a + str->len - 1;
 285         while((p > a) && (*p == 0))
 286         {
 287                 p--;
 288         }
 289         p++;
 290         str->len = p - a;
 291
 292         return str;
 293 }
 294
 295 UString *ustring_upper(UString *str)
 296 {
 297         uint16 *p, *e;
 298
 299         if (! str)
 300         {
 301                 return str;
 302         }
 303
 304         p = str->str;
 305         e = p + str->len;
 306
 307         while (p < e)
 308         {
 309                 *p = toupper(*p);
 310                 p++;
 311         }
 312
 313         return str;
 314 }
 315
 316 UString *ustring_lower(UString *str)
 317 {
 318         uint16 *p, *e;
 319
 320         if (! str)
 321         {
 322                 return str;
 323         }
 324
 325         p = str->str;
 326         e = p + str->len;
 327
 328         while (p < e)
 329         {
 330                 *p = tolower(*p);
 331                 p++;
 332         }
 333
 334         return str;
 335 }
 336
 337 BOOL ustring_equal(const UString *s1, const UString *s2)
 338 {
 339         UString *a;
 340         UString *b;
 341         BOOL ret;
 342
 343         a = ustring_sync_len(ustring_dup(s1));
 344         b = ustring_sync_len(ustring_dup(s2));
 345         ret = ustring_compare_case(a, b);
 346
 347         ustring_free(a);
 348         ustring_free(b);
 349
 350         return ret;
 351 }