libs/basekit/source/UArray_string.c

   1 /*
   2         copyright: Steve Dekorte, 2006. All rights reserved.
   3         license: See _BSDLicense.txt.
   4 */
   5
   6 #include "UArray.h"
   7 #include <string.h>
   8 #include <stdarg.h>
   9 #include <stdio.h>
  10 #include <stddef.h>
  11
  12 void UArray_append_(UArray *self, const UArray *other)
  13 {
  14         UArray_at_putAll_(self, self->size, other);
  15 }
  16
  17 void UArray_appendCString_(UArray *self, const char *s)
  18 {
  19         while (*s)
  20         {
  21                 UArray_appendLong_(self, *s);
  22                 s ++;
  23         }
  24 }
  25
  26 void UArray_prepend_(UArray *self, const UArray *other)
  27 {
  28         UArray_at_putAll_(self, 0, other);
  29 }
  30
  31 int UArray_equalsAnyCase_(const UArray *self, const UArray *other)
  32 {
  33         if (self->size == other->size)
  34         {
  35                 return UArray_findAnyCase_(self, other) == 0;
  36         }
  37
  38         return 0;
  39 }
  40
  41 void UArray_replace_with_(UArray *self, const UArray *a1, const UArray *a2)
  42 {
  43         long i;
  44         size_t start = 0;
  45         UArray visible = UArray_stackRange(self, start, self->size);
  46
  47         while ((i = UArray_find_(&visible, a1)) != -1)
  48         {
  49                 size_t index = start + i;
  50                 UArray_removeRange(self, index, a1->size);
  51                 UArray_at_putAll_(self, index, a2);
  52                 start = index + a2->size;
  53                 visible = UArray_stackRange(self, start, self->size - start);
  54         }
  55         UArray_changed(self);
  56 }
  57
  58 BASEKIT_API void UArray_replaceCString_withCString_(UArray *self, const char *s1, const char *s2)
  59 {
  60         UArray a1 = UArray_stackAllocedWithCString_((char *)s1);
  61         UArray a2 = UArray_stackAllocedWithCString_((char *)s2);
  62         UArray_replace_with_(self, &a1, &a2);
  63 }
  64
  65 void UArray_replaceAnyCase_with_(UArray *self, const UArray *a1, const UArray *a2)
  66 {
  67         long i;
  68         size_t start = 0;
  69         UArray visible = UArray_stackRange(self, start, self->size);
  70
  71         while ((i = UArray_findAnyCase_(&visible, a1)) != -1)
  72         {
  73                 size_t index = start + i;
  74                 UArray_removeRange(self, index, a1->size);
  75                 UArray_at_putAll_(self, index, a2);
  76                 start = index + a2->size;
  77                 visible = UArray_stackRange(self, start, self->size - start);
  78         }
  79
  80         UArray_changed(self);
  81 }
  82
  83 BASEKIT_API void UArray_remove_(UArray *self, const UArray *a1)
  84 {
  85         UArray blank = UArray_stackAllocedEmptyUArray();
  86         UArray_replace_with_(self, a1, &blank);
  87 }
  88
  89 BASEKIT_API void UArray_removeAnyCase_(UArray *self, const UArray *a1)
  90 {
  91         UArray blank = UArray_stackAllocedEmptyUArray();
  92         UArray_replaceAnyCase_with_(self, a1, &blank);
  93 }
  94
  95 // clipping
  96
  97 BASEKIT_API int UArray_clipBefore_(UArray *self, const UArray *other)
  98 {
  99         long index = UArray_find_(self, other);
 100
 101         if (index > -1)
 102         {
 103                 UArray_removeRange(self, 0, index);
 104                 return 1;
 105         }
 106
 107         return 0;
 108 }
 109
 110 BASEKIT_API int UArray_clipBeforeEndOf_(UArray *self, const UArray *other)
 111 {
 112         long index = UArray_find_(self, other);
 113
 114         if (index > -1)
 115         {
 116                 UArray_removeRange(self, 0, index + other->size);
 117                 return 1;
 118         }
 119
 120         return 0;
 121 }
 122
 123 BASEKIT_API int UArray_clipAfter_(UArray *self, const UArray *other)
 124 {
 125         long index = UArray_find_(self, other);
 126
 127         if (index > -1)
 128         {
 129                 UArray_removeRange(self, index + other->size, self->size);
 130                 return 1;
 131         }
 132
 133         return 0;
 134 }
 135
 136 BASEKIT_API int UArray_clipAfterStartOf_(UArray *self, const UArray *other)
 137 {
 138         long index = UArray_find_(self, other);
 139
 140         if (index > -1)
 141         {
 142                 UArray_removeRange(self, index, self->size);
 143                 return 1;
 144         }
 145
 146         return 0;
 147 }
 148
 149 // strip
 150
 151 void UArray_lstrip_(UArray *self, const UArray *other)
 152 {
 153         size_t index = 0;
 154
 155         if (UArray_isFloatType(self))
 156         {
 157                 UARRAY_FOREACH(self, i, v, index = i; if (!UArray_containsDouble_(other, v)) break; )
 158         }
 159         else
 160         {
 161                 UARRAY_FOREACH(self, i, v, index = i; if (!UArray_containsLong_(other, v)) break; )
 162         }
 163
 164         UArray_removeRange(self, 0, index);
 165 }
 166
 167 void UArray_rstrip_(UArray *self, const UArray *other)
 168 {
 169         if (self->size)
 170         {
 171                 size_t index = self->size - 1;
 172
 173                 if (UArray_isFloatType(self))
 174                 {
 175                         UARRAY_RFOREACH(self, i, v, index = i; if (!UArray_containsDouble_(other, v)) break; )
 176                 }
 177                 else
 178                 {
 179                         UARRAY_RFOREACH(self, i, v, index = i; if (!UArray_containsLong_(other, v)) break; )
 180                 }
 181
 182                 UArray_removeRange(self, index + 1, self->size);
 183         }
 184 }
 185
 186 BASEKIT_API void UArray_strip_(UArray *self, const UArray *other)
 187 {
 188         UArray_lstrip_(self, other);
 189         UArray_rstrip_(self, other);
 190 }
 191
 192 // swap
 193
 194 BASEKIT_API void UArray_swapIndex_withIndex_(UArray *self, size_t i, size_t j)
 195 {
 196         int itemSize = self->itemSize;
 197         uint8_t *data = self->data;
 198         void *ip = data + i * itemSize;
 199         void *jp = data + j * itemSize;
 200         UArrayValueUnion b;
 201
 202         memcpy(&b, ip, sizeof(UArray));
 203         memcpy(ip, jp, sizeof(UArray));
 204         memcpy(jp, &b, sizeof(UArray));
 205         UArray_changed(self);
 206 }
 207
 208 // reverse
 209
 210 BASEKIT_API void UArray_reverse(UArray *self)
 211 {
 212         long i = 0;
 213         long j = self->size - 1;
 214         UArrayValueUnion b;
 215         int itemSize = self->itemSize;
 216         uint8_t *data = self->data;
 217
 218         while (j > i)
 219         {
 220                 void *ip = data + i * itemSize;
 221                 void *jp = data + j * itemSize;
 222
 223                 memcpy(&b, ip, itemSize);
 224                 memcpy(ip, jp, itemSize);
 225                 memcpy(jp, &b, itemSize);
 226
 227                 j --;
 228                 i ++;
 229         }
 230
 231         UArray_changed(self);
 232 }
 233
 234 /*
 235 #define UARRAY_MATCHPREFIXLENGTH_TYPES(OP2, TYPE1, self, TYPE2, other)\
 236 {\
 237         long i, minSize = (self->size < other->size) ? self->size : other->size;\
 238         for(i = 0; i < minSize; i ++)\
 239         {\
 240                 TYPE1 v1 = ((TYPE1 *)self->data)[i];\
 241                 TYPE2 v2 = ((TYPE2 *)other->data)[i];\
 242                 if (v1 != v2) break;\
 243         }\
 244         return i;\
 245 }
 246
 247 BASEKIT_API size_t UArray_matchingPrefixSizeWith_(const UArray *self, const UArray *other)
 248 {
 249         DUARRAY_OP(UARRAY_MATCHPREFIXLENGTH_TYPES, NULL, self, other);
 250 }
 251 */
 252
 253 // split
 254
 255 PtrUArray *UArray_split_(const UArray *self, const PtrUArray *delims)
 256 {
 257         PtrUArray *results = UArray_new();
 258         size_t i, last = 0;
 259         UArray_setItemType_(results, CTYPE_uintptr_t);
 260
 261         for (i = 0; i < self->size; i ++)
 262         {
 263                 UArray slice = UArray_stackRange(self, i, self->size - i);
 264                 size_t j;
 265
 266                 for (j = 0; j < delims->size; j ++)
 267                 {
 268                         UArray *delim = UArray_rawPointerAt_(delims, j);
 269
 270                         if (UArray_beginsWith_(&slice, delim))
 271                         {
 272                                 UArray_appendPointer_(results, UArray_range(self, last, i - last));
 273
 274                                 last = i + delim->size;
 275                                 i = last - 1; // since for() will increment it
 276                                 break;
 277                         }
 278                 }
 279         }
 280
 281         if (last != self->size)
 282         {
 283                 UArray_appendPointer_(results, UArray_range(self, last, self->size - last));
 284         }
 285
 286         return results;
 287 }
 288
 289 size_t UArray_splitCount_(const UArray *self, const PtrUArray *delims)
 290 {
 291         PtrUArray *r = UArray_split_(self, delims);
 292         size_t count = UArray_size(r);
 293         UArray_free(r);
 294         return count;
 295 }
 296
 297 // find
 298
 299 BASEKIT_API int UArray_beginsWith_(UArray *self, const UArray *other)
 300 {
 301         if (self->size >= other->size)
 302         {
 303                 UArray tmp = UArray_stackRange(self, 0, other->size);
 304                 return UArray_find_(&tmp, other) != -1;
 305         }
 306
 307         return 0;
 308 }
 309
 310 BASEKIT_API int UArray_endsWith_(UArray *self, const UArray *other)
 311 {
 312         if (self->size >= other->size)
 313         {
 314                 UArray tmp = UArray_stackRange(self, self->size - other->size, other->size);
 315                 return UArray_find_(&tmp, other) != -1;
 316         }
 317
 318         return 0;
 319 }
 320
 321 // escape and quote
 322
 323 void UArray_swapWith_(UArray *self, UArray *other)
 324 {
 325         UArray b;
 326         memcpy(&b, other, sizeof(UArray));
 327         memcpy(other, self, sizeof(UArray));
 328         memcpy(self, &b, sizeof(UArray));
 329         UArray_changed(self);
 330 }
 331
 332 void UArray_escape(UArray *self)
 333 {
 334         UArray *out = UArray_new();
 335         out->itemType = self->itemType;
 336
 337         UARRAY_FOREACH(self, i, v,
 338                 switch ((int)v)
 339                 {
 340                         case '"':  UArray_appendCString_(out, "\\\""); break;
 341                         case '\a': UArray_appendCString_(out, "\\a"); break;
 342                         case '\b': UArray_appendCString_(out, "\\b"); break;
 343                         case '\f': UArray_appendCString_(out, "\\f"); break;
 344                         case '\n': UArray_appendCString_(out, "\\n"); break;
 345                         case '\r': UArray_appendCString_(out, "\\r"); break;
 346                         case '\t': UArray_appendCString_(out, "\\t"); break;
 347                         case '\v': UArray_appendCString_(out, "\\v"); break;
 348                         case '\\': UArray_appendCString_(out, "\\\\"); break;
 349                         default:   UArray_appendLong_(out, v);
 350                 }
 351     );
 352
 353         UArray_swapWith_(self, out);
 354         UArray_free(out);
 355         UArray_changed(self);
 356 }
 357
 358 void UArray_unescape(UArray *self)
 359 {
 360         if (self->itemSize == 1)
 361         {
 362                 int mbskip = 0;  /* multi-byte character size */
 363                 size_t getIndex = 0;
 364                 size_t putIndex = 0;
 365                 char *s = (char *)self->data;
 366
 367                 while (getIndex < self->size)
 368                 {
 369                         int c = s[getIndex];
 370                         int nextChar = s[getIndex + 1];
 371
 372                         if (mbskip <= 0 && ismbchar(c))
 373                         {
 374                                 mbskip = mbcharlen(c);
 375                         }
 376
 377                         if (c != '\\' || mbskip > 0)
 378                         {
 379                                 mbskip --;
 380
 381                                 if (getIndex != putIndex)
 382                                 {
 383                                         s[putIndex] = c;
 384                                 }
 385
 386                                 putIndex ++;
 387                         }
 388                         else
 389                         {
 390                                 char c = nextChar;
 391
 392                                 switch (c)
 393                                 {
 394                                         case  'a': c = '\a'; break;
 395                                         case  'b': c = '\b'; break;
 396                                         case  'f': c = '\f'; break;
 397                                         case  'n': c = '\n'; break;
 398                                         case  'r': c = '\r'; break;
 399                                         case  't': c = '\t'; break;
 400                                         case  'v': c = '\v'; break;
 401                                         case '\0': c = '\\'; break;
 402                                         default:
 403                                                 if (isdigit(c))
 404                                                 {
 405                                                         c -= 48;
 406                                                 }
 407                                 }
 408
 409                                 s[putIndex] = c;
 410                                 getIndex ++;
 411                                 putIndex ++;
 412                         }
 413
 414                         getIndex++;
 415                 }
 416
 417                 UArray_setSize_(self, putIndex);
 418                 UArray_changed(self);
 419                 return;
 420         }
 421         printf("Error: UArray unescape unsupported on type size %i\n", self->itemSize);
 422 }
 423
 424 void UArray_quote(UArray *self)
 425 {
 426         UArray q = UArray_stackAllocedWithCString_("\"");
 427         UArray_prepend_(self, &q);
 428         UArray_append_(self, &q);
 429         UArray_changed(self);
 430 }
 431
 432 void UArray_unquote(UArray *self)
 433 {
 434         UArray q = UArray_stackAllocedWithCString_("\"");
 435
 436         if(UArray_beginsWith_(self, &q) && UArray_endsWith_(self, &q))
 437         {
 438                 UArray_removeFirst(self);
 439                 UArray_removeLast(self);
 440                 UArray_changed(self);
 441         }
 442 }
 443
 444 void UArray_translate(UArray *self, UArray *fromChars, UArray *toChars)
 445 {
 446         size_t max = 4096;
 447         long fromMax = UArray_maxAsDouble(fromChars);
 448         long toMax   = UArray_maxAsDouble(toChars);
 449
 450         if (UArray_size(fromChars) != UArray_size(toChars))
 451         {
 452                 printf("UArray_translate: translation strings must be of the same length");
 453                 return;
 454         }
 455
 456         if ((0 < fromMax && fromMax < max) && (0 < toMax && toMax < 256))
 457         {
 458                 size_t i;
 459                 uint8_t *map = io_calloc(1, fromMax);
 460                 memset(map, 0x0, fromMax);
 461
 462                 for(i = 0; i < UArray_size(fromChars); i ++)
 463                 {
 464                         map[UArray_longAt_(fromChars, i)] = UArray_longAt_(toChars, i);
 465                 }
 466
 467                 for(i = 0; i < UArray_size(self); i ++)
 468                 {
 469                         self->data[i] = map[self->data[i]];
 470                 }
 471
 472                 io_free(map);
 473                 return;
 474         }
 475
 476         /*
 477          UARRAY_FOREACH(self, i, currChar,
 478                                  UARRAY_FOREACH(fromChars, j, fromChar,
 479                                                          if(currChar == fromChar)
 480                                                          {
 481                                                                  UARRAY_RAWAT_PUT_(self, i, UARRAY_RAWAT_(toChars, j));
 482                                                                  break;
 483                                                          }
 484                                                          );
 485                                  );
 486          */
 487
 488         UArray_error_(self, "UArray_translate unimplemented for this type");
 489 }
 490
 491 size_t UArray_count_(const UArray *self, const UArray *other)
 492 {
 493         long i = 0;
 494         size_t count = 0;
 495
 496         while ((i = UArray_find_from_(self, other, i)) != -1)
 497         {
 498                 i += UArray_size(other);
 499                 count ++;
 500         }
 501
 502         return count;
 503 }