ctags/main/vstring.c

   1 /*
   2 *   Copyright (c) 1998-2002, Darren Hiebert
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License version 2 or (at your option) any later version.
   6 *
   7 *   This module contains functions supporting resizeable strings.
   8 */
   9
  10 /*
  11 *   INCLUDE FILES
  12 */
  13 #include "general.h"  /* must always come first */
  14
  15 #include <limits.h>  /* to define INT_MAX */
  16 #include <string.h>
  17 #include <ctype.h>
  18
  19 #include "debug.h"
  20 #include "routines.h"
  21 #include "vstring.h"
  22 #include "trashbox.h"
  23
  24 /*
  25 *   DATA DEFINITIONS
  26 */
  27 static const size_t vStringInitialSize = 32;
  28
  29 /*
  30 *   FUNCTION DEFINITIONS
  31 */
  32
  33 /*
  34 *   External interface
  35 */
  36
  37 extern void vStringResize (vString *const string, const size_t newSize)
  38 {
  39         size_t size = vStringInitialSize;
  40
  41         while (size < newSize)
  42                 size *= 2;
  43
  44         if (size > string->size)
  45         {
  46                 string->size = size;
  47                 string->buffer = xRealloc (string->buffer, size, char);
  48         }
  49 }
  50
  51 extern void vStringTruncate (vString *const string, const size_t length)
  52 {
  53         Assert (length <= string->length);
  54         string->length = length;
  55         string->buffer[string->length] = '\0';
  56         DebugStatement ( memset (string->buffer + string->length, 0,
  57                                  string->size - string->length); )
  58 }
  59
  60 extern void vStringDelete (vString *const string)
  61 {
  62         if (string != NULL)
  63         {
  64                 if (string->buffer != NULL)
  65                         eFree (string->buffer);
  66                 eFree (string);
  67         }
  68 }
  69
  70 extern vString *vStringNew (void)
  71 {
  72         vString *const string = xMalloc (1, vString);
  73
  74         string->length = 0;
  75         string->size   = vStringInitialSize;
  76         string->buffer = xMalloc (string->size, char);
  77
  78         vStringClear (string);
  79
  80         return string;
  81 }
  82
  83 extern vString *vStringNewCopy (const vString *const string)
  84 {
  85         vString *vs = vStringNew ();
  86         vStringCatS (vs, string->buffer);
  87         return vs;
  88 }
  89
  90 extern vString *vStringNewInit (const char *const s)
  91 {
  92         vString *vs = vStringNew ();
  93         vStringCatS (vs, s);
  94         return vs;
  95 }
  96
  97 extern vString *vStringNewNInit (const char *const s, const size_t length)
  98 {
  99         vString *vs = vStringNew ();
 100         vStringNCatS (vs, s, length);
 101         return vs;
 102 }
 103
 104 static void stringCat (
 105                 vString *const string, const char *const s, const size_t length)
 106 {
 107         if (string->length + length + 1 > string->size)
 108                 vStringResize (string, string->length + length + 1);
 109
 110         memcpy (string->buffer + string->length, s, length);
 111         string->length += length;
 112         vStringPut (string, '\0');
 113 }
 114
 115 extern void vStringNCat (
 116                 vString *const string, const vString *const s, const size_t length)
 117 {
 118         size_t len = vStringLength (s);
 119
 120         len = len < length ? len: length;
 121         stringCat (string, s->buffer, len);
 122 }
 123
 124 extern void vStringNCatS (
 125                 vString *const string, const char *const s, const size_t length)
 126 {
 127         size_t len = strnlen (s, length);
 128
 129         stringCat (string, s, len);
 130 }
 131
 132 extern void vStringNCatSUnsafe (
 133                 vString *const string, const char *const s, const size_t length)
 134 {
 135         stringCat (string, s, length);
 136 }
 137
 138 extern void vStringCat (vString *const string, const vString *const s)
 139 {
 140         size_t len = vStringLength (s);
 141
 142         stringCat (string, s->buffer, len);
 143 }
 144
 145 extern void vStringCatS (vString *const string, const char *const s)
 146 {
 147         size_t len = strlen (s);
 148
 149         stringCat (string, s, len);
 150 }
 151
 152 /*  Strip trailing newline from string.
 153  */
 154 extern bool vStringStripNewline (vString *const string)
 155 {
 156         const size_t final = string->length - 1;
 157
 158         if (string->length == 0)
 159                 return false;
 160
 161         if (string->buffer [final] == '\n')
 162         {
 163                 string->buffer [final] = '\0';
 164                 string->length--;
 165                 return true;
 166         }
 167
 168         return false;
 169 }
 170
 171 /*  Strip leading white space from string.
 172  */
 173 extern void vStringStripLeading (vString *const string)
 174 {
 175         size_t n = 0;
 176
 177         while (n < string->length && isspace ((unsigned char) string->buffer [n]))
 178                 n++;
 179         vStringTruncateLeading (string, n);
 180 }
 181
 182 extern void vStringTruncateLeading (vString *const string, const size_t length)
 183 {
 184         size_t n = vStringLength (string);
 185         if (n > length)
 186                 n = length;
 187         if (n > 0)
 188         {
 189                 memmove (string->buffer, string->buffer + n, string->length - n);
 190                 vStringTruncate (string, string->length - n);
 191         }
 192 }
 193
 194 /*  Strip trailing white space from string.
 195  */
 196 extern void vStringStripTrailing (vString *const string)
 197 {
 198         while (string->length > 0 &&
 199                isspace ((unsigned char) string->buffer [string->length - 1]))
 200         {
 201                 string->length--;
 202                 string->buffer [string->length] = '\0';
 203         }
 204 }
 205
 206 /*  Chop last character from string.
 207  */
 208 extern void vStringChop (vString *const string)
 209 {
 210         if (string->length > 0)
 211         {
 212                 --string->length;
 213                 string->buffer [string->length] = '\0';
 214         }
 215 }
 216
 217 extern void vStringCopy (vString *const string, const vString *const s)
 218 {
 219         vStringClear (string);
 220         vStringCat (string, s);
 221 }
 222
 223 extern void vStringCopyS (vString *const string, const char *const s)
 224 {
 225         vStringClear (string);
 226         vStringCatS (string, s);
 227 }
 228
 229 extern void vStringNCopy (
 230                 vString *const string, const vString *const s, const size_t length)
 231 {
 232         vStringClear (string);
 233         vStringNCat (string, s, length);
 234 }
 235
 236 extern void vStringNCopyS (
 237                 vString *const string, const char *const s, const size_t length)
 238 {
 239         vStringClear (string);
 240         vStringNCatS (string, s, length);
 241 }
 242
 243 extern void vStringNCopySUnsafe (
 244                 vString *const string, const char *const s, const size_t length)
 245 {
 246         vStringClear (string);
 247         vStringNCatSUnsafe (string, s, length);
 248 }
 249
 250 extern void vStringCopyToLower (vString *const dest, const vString *const src)
 251 {
 252         const size_t length = src->length;
 253         const char *s = src->buffer;
 254         char *d;
 255         size_t i;
 256
 257         if (dest->size < src->size)
 258                 vStringResize (dest, src->size);
 259         d = dest->buffer;
 260         for (i = 0  ;  i < length  ;  ++i)
 261                 d [i] = (char) tolower ((unsigned char) s [i]);
 262         d [i] = '\0';
 263 }
 264
 265 extern void vStringSetLength (vString *const string)
 266 {
 267         string->length = strlen (string->buffer);
 268 }
 269
 270 extern vString *vStringNewOwn (char *s)
 271 {
 272         vString *r;
 273
 274         r = vStringNewInit (s);
 275         eFree (s);
 276
 277         return r;
 278 }
 279
 280 extern char    *vStringDeleteUnwrap       (vString *const string)
 281 {
 282         char *buffer = NULL;
 283
 284
 285         if (string != NULL)
 286         {
 287                 buffer = string->buffer;
 288                 string->buffer = NULL;
 289
 290                 string->size = 0;
 291                 string->length = 0;
 292
 293                 eFree (string);
 294         }
 295
 296         return buffer;
 297 }
 298
 299 extern char    *vStringStrdup (const vString *const string)
 300 {
 301         char *str = xMalloc (vStringLength(string) + 1, char);
 302         str[vStringLength(string)] = '\0';
 303         memcpy (str, string->buffer, vStringLength(string));
 304         return str;
 305 }
 306
 307 static int valueToXDigit (int v)
 308 {
 309         Assert (v >= 0 && v <= 0xF);
 310
 311         if (v >= 0xA)
 312                 return 'A' + (v - 0xA);
 313         else
 314                 return '0' + v;
 315 }
 316
 317 extern void vStringCatSWithEscaping (vString* b, const char *s)
 318 {
 319         for(; *s; s++)
 320         {
 321                 unsigned char c = (unsigned char) *s;
 322
 323                 /* escape control characters (incl. \t) */
 324                 if ((c > 0x00 && c <= 0x1F) || c == 0x7F || c == '\\')
 325                 {
 326                         vStringPut (b, '\\');
 327
 328                         switch (c)
 329                         {
 330                                 /* use a short form for known escapes */
 331                         case '\a':
 332                                 c = 'a'; break;
 333                         case '\b':
 334                                 c = 'b'; break;
 335                         case '\t':
 336                                 c = 't'; break;
 337                         case '\n':
 338                                 c = 'n'; break;
 339                         case '\v':
 340                                 c = 'v'; break;
 341                         case '\f':
 342                                 c = 'f'; break;
 343                         case '\r':
 344                                 c = 'r'; break;
 345                         case '\\':
 346                                 c = '\\'; break;
 347                         default:
 348                                 vStringPut (b, 'x');
 349                                 vStringPut (b, valueToXDigit ((c & 0xF0) >> 4));
 350                                 vStringPut (b, valueToXDigit (c & 0x0F));
 351                                 continue;
 352                         }
 353                 }
 354                 vStringPut (b, c);
 355         }
 356 }
 357
 358 extern void vStringCatSWithEscapingAsPattern (vString *output, const char* input)
 359 {
 360         while (*input)
 361         {
 362                 switch (*input)
 363                 {
 364                 case '\\':
 365                         vStringPut(output, '\\');
 366                         vStringPut(output, '\\');
 367                         break;
 368                 case '/':
 369                         vStringPut(output, '\\');
 370                         vStringPut(output, '/');
 371                         break;
 372                 default:
 373                         vStringPut(output, *input);
 374                         break;
 375
 376                 }
 377                 input++;
 378         }
 379 }
 380
 381 extern vString *vStringNewOrClear (vString *const string)
 382 {
 383         if (string)
 384         {
 385                 vStringClear (string);
 386                 return string;
 387         }
 388         else
 389                 return vStringNew ();
 390 }
 391
 392 extern vString *vStringNewOrClearWithAutoRelease (vString *const string)
 393 {
 394         vString *r;
 395
 396         bool autoRelease = false;
 397         if (!string)
 398                 autoRelease = true;
 399
 400         r = vStringNewOrClear(string);
 401         if (autoRelease)
 402                 DEFAULT_TRASH_BOX(r, vStringDelete);
 403
 404         return r;
 405 }
 406
 407 extern void vStringTranslate(vString *const string, char fromC, char toC)
 408 {
 409         for (unsigned int i = 0; i < vStringLength(string); i++)
 410         {
 411                 if (string->buffer[i] == fromC)
 412                         string->buffer[i] = toC;
 413         }
 414 }