xref: /haiku/src/libs/zydis/Zycore/String.c (revision caed67a8cba83913b9c21ac2b06ebc6bd1cb3111) 
1 /***************************************************************************************************
2 
3   Zyan Core Library (Zycore-C)
4 
5   Original Author : Florian Bernd
6 
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in all
15  * copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23  * SOFTWARE.
24 
25 ***************************************************************************************************/
26 
27 #include <Zycore/String.h>
28 #include <Zycore/LibC.h>
29 
30 /* ============================================================================================== */
31 /* Internal macros                                                                                */
32 /* ============================================================================================== */
33 
34 /**
35  * Writes a terminating '\0' character at the end of the string data.
36  */
37 #define ZYCORE_STRING_NULLTERMINATE(string) \
38       *(char*)((ZyanU8*)(string)->vector.data + (string)->vector.size - 1) = '\0';
39 
40 /**
41  * Checks for a terminating '\0' character at the end of the string data.
42  */
43 #define ZYCORE_STRING_ASSERT_NULLTERMINATION(string) \
44       ZYAN_ASSERT(*(char*)((ZyanU8*)(string)->vector.data + (string)->vector.size - 1) == '\0');
45 
46 /* ============================================================================================== */
47 /* Exported functions                                                                             */
48 /* ============================================================================================== */
49 
50 /* ---------------------------------------------------------------------------------------------- */
51 /* Constructor and destructor                                                                     */
52 /* ---------------------------------------------------------------------------------------------- */
53 
54 #ifndef ZYAN_NO_LIBC
55 
56 ZyanStatus ZyanStringInit(ZyanString* string, ZyanUSize capacity)
57 {
58     return ZyanStringInitEx(string, capacity, ZyanAllocatorDefault(),
59         ZYAN_STRING_DEFAULT_GROWTH_FACTOR, ZYAN_STRING_DEFAULT_SHRINK_THRESHOLD);
60 }
61 
62 #endif // ZYAN_NO_LIBC
63 
64 ZyanStatus ZyanStringInitEx(ZyanString* string, ZyanUSize capacity, ZyanAllocator* allocator,
65     ZyanU8 growth_factor, ZyanU8 shrink_threshold)
66 {
67     if (!string)
68     {
69         return ZYAN_STATUS_INVALID_ARGUMENT;
70     }
71 
72     string->flags = 0;
73     capacity = ZYAN_MAX(ZYAN_STRING_MIN_CAPACITY, capacity) + 1;
74     ZYAN_CHECK(ZyanVectorInitEx(&string->vector, sizeof(char), capacity, ZYAN_NULL, allocator,
75         growth_factor, shrink_threshold));
76     ZYAN_ASSERT(string->vector.capacity >= capacity);
77     // Some of the string code relies on `sizeof(char) == 1`
78     ZYAN_ASSERT(string->vector.element_size == 1);
79 
80     *(char*)string->vector.data = '\0';
81     ++string->vector.size;
82 
83     return ZYAN_STATUS_SUCCESS;
84 }
85 
86 ZyanStatus ZyanStringInitCustomBuffer(ZyanString* string, char* buffer, ZyanUSize capacity)
87 {
88     if (!string || !capacity)
89     {
90         return ZYAN_STATUS_INVALID_ARGUMENT;
91     }
92 
93     string->flags = ZYAN_STRING_HAS_FIXED_CAPACITY;
94     ZYAN_CHECK(ZyanVectorInitCustomBuffer(&string->vector, sizeof(char), (void*)buffer, capacity,
95         ZYAN_NULL));
96     ZYAN_ASSERT(string->vector.capacity == capacity);
97     // Some of the string code relies on `sizeof(char) == 1`
98     ZYAN_ASSERT(string->vector.element_size == 1);
99 
100     *(char*)string->vector.data = '\0';
101     ++string->vector.size;
102 
103     return ZYAN_STATUS_SUCCESS;
104 }
105 
106 ZyanStatus ZyanStringDestroy(ZyanString* string)
107 {
108     if (!string)
109     {
110         return ZYAN_STATUS_INVALID_ARGUMENT;
111     }
112     if (string->flags & ZYAN_STRING_HAS_FIXED_CAPACITY)
113     {
114         return ZYAN_STATUS_SUCCESS;
115     }
116 
117     return ZyanVectorDestroy(&string->vector);
118 }
119 
120 /* ---------------------------------------------------------------------------------------------- */
121 /* Duplication                                                                                    */
122 /* ---------------------------------------------------------------------------------------------- */
123 
124 #ifndef ZYAN_NO_LIBC
125 
126 ZyanStatus ZyanStringDuplicate(ZyanString* destination, const ZyanStringView* source,
127     ZyanUSize capacity)
128 {
129     return ZyanStringDuplicateEx(destination, source, capacity, ZyanAllocatorDefault(),
130         ZYAN_STRING_DEFAULT_GROWTH_FACTOR, ZYAN_STRING_DEFAULT_SHRINK_THRESHOLD);
131 }
132 
133 #endif // ZYAN_NO_LIBC
134 
135 ZyanStatus ZyanStringDuplicateEx(ZyanString* destination, const ZyanStringView* source,
136     ZyanUSize capacity, ZyanAllocator* allocator, ZyanU8 growth_factor, ZyanU8 shrink_threshold)
137 {
138     if (!source || !source->string.vector.size)
139     {
140         return ZYAN_STATUS_INVALID_ARGUMENT;
141     }
142 
143     const ZyanUSize len = source->string.vector.size;
144     capacity = ZYAN_MAX(capacity, len - 1);
145     ZYAN_CHECK(ZyanStringInitEx(destination, capacity, allocator, growth_factor, shrink_threshold));
146     ZYAN_ASSERT(destination->vector.capacity >= len);
147 
148     ZYAN_MEMCPY(destination->vector.data, source->string.vector.data,
149         source->string.vector.size - 1);
150     destination->vector.size = len;
151     ZYCORE_STRING_NULLTERMINATE(destination);
152 
153     return ZYAN_STATUS_SUCCESS;
154 }
155 
156 ZyanStatus ZyanStringDuplicateCustomBuffer(ZyanString* destination, const ZyanStringView* source,
157     char* buffer, ZyanUSize capacity)
158 {
159     if (!source || !source->string.vector.size)
160     {
161         return ZYAN_STATUS_INVALID_ARGUMENT;
162     }
163 
164     const ZyanUSize len = source->string.vector.size;
165     if (capacity < len)
166     {
167         return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
168     }
169 
170     ZYAN_CHECK(ZyanStringInitCustomBuffer(destination, buffer, capacity));
171     ZYAN_ASSERT(destination->vector.capacity >= len);
172 
173     ZYAN_MEMCPY(destination->vector.data, source->string.vector.data,
174         source->string.vector.size - 1);
175     destination->vector.size = len;
176     ZYCORE_STRING_NULLTERMINATE(destination);
177 
178     return ZYAN_STATUS_SUCCESS;
179 }
180 
181 /* ---------------------------------------------------------------------------------------------- */
182 /* Concatenation                                                                                  */
183 /* ---------------------------------------------------------------------------------------------- */
184 
185 #ifndef ZYAN_NO_LIBC
186 
187 ZyanStatus ZyanStringConcat(ZyanString* destination, const ZyanStringView* s1,
188     const ZyanStringView* s2, ZyanUSize capacity)
189 {
190     return ZyanStringConcatEx(destination, s1, s2, capacity, ZyanAllocatorDefault(),
191         ZYAN_STRING_DEFAULT_GROWTH_FACTOR, ZYAN_STRING_DEFAULT_SHRINK_THRESHOLD);
192 }
193 
194 #endif // ZYAN_NO_LIBC
195 
196 ZyanStatus ZyanStringConcatEx(ZyanString* destination, const ZyanStringView* s1,
197     const ZyanStringView* s2, ZyanUSize capacity, ZyanAllocator* allocator, ZyanU8 growth_factor,
198     ZyanU8 shrink_threshold)
199 {
200     if (!s1 || !s2 || !s1->string.vector.size || !s2->string.vector.size)
201     {
202         return ZYAN_STATUS_INVALID_ARGUMENT;
203     }
204 
205     const ZyanUSize len = s1->string.vector.size + s2->string.vector.size - 1;
206     capacity = ZYAN_MAX(capacity, len - 1);
207     ZYAN_CHECK(ZyanStringInitEx(destination, capacity, allocator, growth_factor, shrink_threshold));
208     ZYAN_ASSERT(destination->vector.capacity >= len);
209 
210     ZYAN_MEMCPY(destination->vector.data, s1->string.vector.data, s1->string.vector.size - 1);
211     ZYAN_MEMCPY((char*)destination->vector.data + s1->string.vector.size - 1,
212         s2->string.vector.data, s2->string.vector.size - 1);
213     destination->vector.size = len;
214     ZYCORE_STRING_NULLTERMINATE(destination);
215 
216     return ZYAN_STATUS_SUCCESS;
217 }
218 
219 ZyanStatus ZyanStringConcatCustomBuffer(ZyanString* destination, const ZyanStringView* s1,
220     const ZyanStringView* s2, char* buffer, ZyanUSize capacity)
221 {
222     if (!s1 || !s2 || !s1->string.vector.size || !s2->string.vector.size)
223     {
224         return ZYAN_STATUS_INVALID_ARGUMENT;
225     }
226 
227     const ZyanUSize len = s1->string.vector.size + s2->string.vector.size - 1;
228     if (capacity < len)
229     {
230         return ZYAN_STATUS_INSUFFICIENT_BUFFER_SIZE;
231     }
232 
233     ZYAN_CHECK(ZyanStringInitCustomBuffer(destination, buffer, capacity));
234     ZYAN_ASSERT(destination->vector.capacity >= len);
235 
236     ZYAN_MEMCPY(destination->vector.data, s1->string.vector.data, s1->string.vector.size - 1);
237     ZYAN_MEMCPY((char*)destination->vector.data + s1->string.vector.size - 1,
238         s2->string.vector.data, s2->string.vector.size - 1);
239     destination->vector.size = len;
240     ZYCORE_STRING_NULLTERMINATE(destination);
241 
242     return ZYAN_STATUS_SUCCESS;
243 }
244 
245 /* ---------------------------------------------------------------------------------------------- */
246 /* Views                                                                                          */
247 /* ---------------------------------------------------------------------------------------------- */
248 
249 ZyanStatus ZyanStringViewInsideView(ZyanStringView* view, const ZyanStringView* source)
250 {
251     if (!view || !source)
252     {
253         return ZYAN_STATUS_INVALID_ARGUMENT;
254     }
255 
256     view->string.vector.data = source->string.vector.data;
257     view->string.vector.size = source->string.vector.size;
258 
259     return ZYAN_STATUS_SUCCESS;
260 }
261 
262 ZyanStatus ZyanStringViewInsideViewEx(ZyanStringView* view, const ZyanStringView* source,
263     ZyanUSize index, ZyanUSize count)
264 {
265     if (!view || !source)
266     {
267         return ZYAN_STATUS_INVALID_ARGUMENT;
268     }
269 
270     if (index + count >= source->string.vector.size)
271     {
272         return ZYAN_STATUS_OUT_OF_RANGE;
273     }
274 
275     view->string.vector.data = (void*)((char*)source->string.vector.data + index);
276     view->string.vector.size = count;
277 
278     return ZYAN_STATUS_SUCCESS;
279 }
280 
281 ZyanStatus ZyanStringViewInsideBuffer(ZyanStringView* view, const char* string)
282 {
283     if (!view || !string)
284     {
285         return ZYAN_STATUS_INVALID_ARGUMENT;
286     }
287 
288     view->string.vector.data = (void*)string;
289     view->string.vector.size = ZYAN_STRLEN(string) + 1;
290 
291     return ZYAN_STATUS_SUCCESS;
292 }
293 
294 ZyanStatus ZyanStringViewInsideBufferEx(ZyanStringView* view, const char* buffer, ZyanUSize length)
295 {
296     if (!view || !buffer || !length)
297     {
298         return ZYAN_STATUS_INVALID_ARGUMENT;
299     }
300 
301     view->string.vector.data = (void*)buffer;
302     view->string.vector.size = length + 1;
303 
304     return ZYAN_STATUS_SUCCESS;
305 }
306 
307 ZyanStatus ZyanStringViewGetSize(const ZyanStringView* view, ZyanUSize* size)
308 {
309     if (!view || !size)
310     {
311         return ZYAN_STATUS_INVALID_ARGUMENT;
312     }
313 
314     ZYAN_ASSERT(view->string.vector.size >= 1);
315     *size = view->string.vector.size - 1;
316 
317     return ZYAN_STATUS_SUCCESS;
318 }
319 
320 ZYCORE_EXPORT ZyanStatus ZyanStringViewGetData(const ZyanStringView* view, const char** buffer)
321 {
322     if (!view || !buffer)
323     {
324         return ZYAN_STATUS_INVALID_ARGUMENT;
325     }
326 
327     *buffer = view->string.vector.data;
328 
329     return ZYAN_STATUS_SUCCESS;
330 }
331 
332 /* ---------------------------------------------------------------------------------------------- */
333 /* Character access                                                                               */
334 /* ---------------------------------------------------------------------------------------------- */
335 
336 ZyanStatus ZyanStringGetChar(const ZyanStringView* string, ZyanUSize index, char* value)
337 {
338     if (!string || !value)
339     {
340         return ZYAN_STATUS_INVALID_ARGUMENT;
341     }
342 
343     // Don't allow direct access to the terminating '\0' character
344     if (index + 1 >= string->string.vector.size)
345     {
346         return ZYAN_STATUS_OUT_OF_RANGE;
347     }
348 
349     const char* chr;
350     ZYAN_CHECK(ZyanVectorGetPointer(&string->string.vector, index, (const void**)&chr));
351     *value = *chr;
352 
353     return ZYAN_STATUS_SUCCESS;
354 }
355 
356 ZyanStatus ZyanStringGetCharMutable(ZyanString* string, ZyanUSize index, char** value)
357 {
358     if (!string)
359     {
360         return ZYAN_STATUS_INVALID_ARGUMENT;
361     }
362 
363     // Don't allow direct access to the terminating '\0' character
364     if (index + 1 >= string->vector.size)
365     {
366         return ZYAN_STATUS_OUT_OF_RANGE;
367     }
368 
369     return ZyanVectorGetPointerMutable(&string->vector, index, (void**)value);
370 }
371 
372 ZyanStatus ZyanStringSetChar(ZyanString* string, ZyanUSize index, char value)
373 {
374     if (!string)
375     {
376         return ZYAN_STATUS_INVALID_ARGUMENT;
377     }
378 
379     // Don't allow direct access to the terminating '\0' character
380     if (index + 1 >= string->vector.size)
381     {
382         return ZYAN_STATUS_OUT_OF_RANGE;
383     }
384 
385     return ZyanVectorSet(&string->vector, index, (void*)&value);
386 }
387 
388 /* ---------------------------------------------------------------------------------------------- */
389 /* Insertion                                                                                      */
390 /* ---------------------------------------------------------------------------------------------- */
391 
392 ZyanStatus ZyanStringInsert(ZyanString* destination, ZyanUSize index, const ZyanStringView* source)
393 {
394     if (!destination || !source || !source->string.vector.size)
395     {
396         return ZYAN_STATUS_INVALID_ARGUMENT;
397     }
398 
399     if (index == destination->vector.size)
400     {
401         return ZyanStringAppend(destination, source);
402     }
403 
404     // Don't allow insertion after the terminating '\0' character
405     if (index >= destination->vector.size)
406     {
407         return ZYAN_STATUS_OUT_OF_RANGE;
408     }
409 
410     ZYAN_CHECK(ZyanVectorInsertRange(&destination->vector, index, source->string.vector.data,
411         source->string.vector.size - 1));
412     ZYCORE_STRING_ASSERT_NULLTERMINATION(destination);
413 
414     return ZYAN_STATUS_SUCCESS;
415 }
416 
417 ZyanStatus ZyanStringInsertEx(ZyanString* destination, ZyanUSize destination_index,
418     const ZyanStringView* source, ZyanUSize source_index, ZyanUSize count)
419 {
420     if (!destination || !source || !source->string.vector.size)
421     {
422         return ZYAN_STATUS_INVALID_ARGUMENT;
423     }
424 
425     if (destination_index == destination->vector.size)
426     {
427         return ZyanStringAppendEx(destination, source, source_index, count);
428     }
429 
430     // Don't allow insertion after the terminating '\0' character
431     if (destination_index >= destination->vector.size)
432     {
433         return ZYAN_STATUS_OUT_OF_RANGE;
434     }
435 
436     // Don't allow access to the terminating '\0' character
437     if (source_index + count >= source->string.vector.size)
438     {
439         return ZYAN_STATUS_OUT_OF_RANGE;
440     }
441 
442     ZYAN_CHECK(ZyanVectorInsertRange(&destination->vector, destination_index,
443         (char*)source->string.vector.data + source_index, count));
444     ZYCORE_STRING_ASSERT_NULLTERMINATION(destination);
445 
446     return ZYAN_STATUS_SUCCESS;
447 }
448 
449 /* ---------------------------------------------------------------------------------------------- */
450 /* Appending                                                                                      */
451 /* ---------------------------------------------------------------------------------------------- */
452 
453 ZyanStatus ZyanStringAppend(ZyanString* destination, const ZyanStringView* source)
454 {
455     if (!destination || !source || !source->string.vector.size)
456     {
457         return ZYAN_STATUS_INVALID_ARGUMENT;
458     }
459 
460     const ZyanUSize len = destination->vector.size;
461     ZYAN_CHECK(ZyanVectorResize(&destination->vector, len + source->string.vector.size - 1));
462     ZYAN_MEMCPY((char*)destination->vector.data + len - 1, source->string.vector.data,
463         source->string.vector.size - 1);
464     ZYCORE_STRING_NULLTERMINATE(destination);
465 
466     return ZYAN_STATUS_SUCCESS;
467 }
468 
469 ZyanStatus ZyanStringAppendEx(ZyanString* destination, const ZyanStringView* source,
470     ZyanUSize source_index, ZyanUSize count)
471 {
472     if (!destination || !source || !source->string.vector.size)
473     {
474         return ZYAN_STATUS_INVALID_ARGUMENT;
475     }
476 
477     // Don't allow access to the terminating '\0' character
478     if (source_index + count >= source->string.vector.size)
479     {
480         return ZYAN_STATUS_OUT_OF_RANGE;
481     }
482 
483     const ZyanUSize len = destination->vector.size;
484     ZYAN_CHECK(ZyanVectorResize(&destination->vector, len + count));
485     ZYAN_MEMCPY((char*)destination->vector.data + len - 1,
486         (const char*)source->string.vector.data + source_index, count);
487     ZYCORE_STRING_NULLTERMINATE(destination);
488 
489     return ZYAN_STATUS_SUCCESS;
490 }
491 
492 /* ---------------------------------------------------------------------------------------------- */
493 /* Deletion                                                                                       */
494 /* ---------------------------------------------------------------------------------------------- */
495 
496 ZyanStatus ZyanStringDelete(ZyanString* string, ZyanUSize index, ZyanUSize count)
497 {
498     if (!string)
499     {
500         return ZYAN_STATUS_INVALID_ARGUMENT;
501     }
502 
503     // Don't allow removal of the terminating '\0' character
504     if (index + count >= string->vector.size)
505     {
506         return ZYAN_STATUS_OUT_OF_RANGE;
507     }
508 
509     ZYAN_CHECK(ZyanVectorDeleteRange(&string->vector, index, count));
510     ZYCORE_STRING_NULLTERMINATE(string);
511 
512     return ZYAN_STATUS_SUCCESS;
513 }
514 
515 ZyanStatus ZyanStringTruncate(ZyanString* string, ZyanUSize index)
516 {
517     if (!string)
518     {
519         return ZYAN_STATUS_INVALID_ARGUMENT;
520     }
521 
522     // Don't allow removal of the terminating '\0' character
523     if (index >= string->vector.size)
524     {
525         return ZYAN_STATUS_OUT_OF_RANGE;
526     }
527 
528     ZYAN_CHECK(ZyanVectorDeleteRange(&string->vector, index, string->vector.size - index - 1));
529     ZYCORE_STRING_NULLTERMINATE(string);
530 
531     return ZYAN_STATUS_SUCCESS;
532 }
533 
534 ZyanStatus ZyanStringClear(ZyanString* string)
535 {
536     if (!string)
537     {
538         return ZYAN_STATUS_INVALID_ARGUMENT;
539     }
540 
541     ZYAN_CHECK(ZyanVectorClear(&string->vector));
542     // `ZyanVector` guarantees a minimum capacity of 1 element/character
543     ZYAN_ASSERT(string->vector.capacity >= 1);
544 
545     *(char*)string->vector.data = '\0';
546     string->vector.size++;
547 
548     return ZYAN_STATUS_SUCCESS;
549 }
550 
551 /* ---------------------------------------------------------------------------------------------- */
552 /* Searching                                                                                      */
553 /* ---------------------------------------------------------------------------------------------- */
554 
555 ZyanStatus ZyanStringLPos(const ZyanStringView* haystack, const ZyanStringView* needle,
556     ZyanISize* found_index)
557 {
558     if (!haystack)
559     {
560         return ZYAN_STATUS_INVALID_ARGUMENT;
561     }
562 
563     return ZyanStringLPosEx(haystack, needle, found_index, 0, haystack->string.vector.size - 1);
564 }
565 
566 ZyanStatus ZyanStringLPosEx(const ZyanStringView* haystack, const ZyanStringView* needle,
567     ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
568 {
569     if (!haystack || !needle || !found_index)
570     {
571         return ZYAN_STATUS_INVALID_ARGUMENT;
572     }
573 
574     // Don't allow access to the terminating '\0' character
575     if (index + count >= haystack->string.vector.size)
576     {
577         return ZYAN_STATUS_OUT_OF_RANGE;
578     }
579 
580     if ((haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
581         (haystack->string.vector.size < needle->string.vector.size))
582     {
583         *found_index = -1;
584         return ZYAN_STATUS_FALSE;
585     }
586 
587     const char* s = (const char*)haystack->string.vector.data + index;
588     const char* b = (const char*)needle->string.vector.data;
589     for (; s + 1 < (const char*)haystack->string.vector.data + haystack->string.vector.size; ++s)
590     {
591         if (*s != *b)
592         {
593             continue;
594         }
595         const char* a = s;
596         for (;;)
597         {
598             if ((ZyanUSize)(a - (const char*)haystack->string.vector.data) > index + count)
599             {
600                 *found_index = -1;
601                 return ZYAN_STATUS_FALSE;
602             }
603             if (*b == 0)
604             {
605                 *found_index = (ZyanISize)(s - (const char*)haystack->string.vector.data);
606                 return ZYAN_STATUS_TRUE;
607             }
608             if (*a++ != *b++)
609             {
610                 break;
611             }
612         }
613         b = (char*)needle->string.vector.data;
614     }
615 
616     *found_index = -1;
617     return ZYAN_STATUS_FALSE;
618 }
619 
620 ZyanStatus ZyanStringLPosI(const ZyanStringView* haystack, const ZyanStringView* needle,
621     ZyanISize* found_index)
622 {
623     if (!haystack)
624     {
625         return ZYAN_STATUS_INVALID_ARGUMENT;
626     }
627 
628     return ZyanStringLPosIEx(haystack, needle, found_index, 0, haystack->string.vector.size - 1);
629 }
630 
631 ZyanStatus ZyanStringLPosIEx(const ZyanStringView* haystack, const ZyanStringView* needle,
632     ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
633 {
634     // This solution assumes that characters are represented using ASCII representation, i.e.,
635     // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
636     // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
637 
638     if (!haystack || !needle || !found_index)
639     {
640         return ZYAN_STATUS_INVALID_ARGUMENT;
641     }
642 
643     // Don't allow access to the terminating '\0' character
644     if (index + count >= haystack->string.vector.size)
645     {
646         return ZYAN_STATUS_OUT_OF_RANGE;
647     }
648 
649     if ((haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
650         (haystack->string.vector.size < needle->string.vector.size))
651     {
652         *found_index = -1;
653         return ZYAN_STATUS_FALSE;
654     }
655 
656     const char* s = (const char*)haystack->string.vector.data + index;
657     const char* b = (const char*)needle->string.vector.data;
658     for (; s + 1 < (const char*)haystack->string.vector.data + haystack->string.vector.size; ++s)
659     {
660         if ((*s != *b) && ((*s ^ 32) != *b))
661         {
662             continue;
663         }
664         const char* a = s;
665         for (;;)
666         {
667             if ((ZyanUSize)(a - (const char*)haystack->string.vector.data) > index + count)
668             {
669                 *found_index = -1;
670                 return ZYAN_STATUS_FALSE;
671             }
672             if (*b == 0)
673             {
674                 *found_index = (ZyanISize)(s - (const char*)haystack->string.vector.data);
675                 return ZYAN_STATUS_TRUE;
676             }
677             const char c1 = *a++;
678             const char c2 = *b++;
679             if ((c1 != c2) && ((c1 ^ 32) != c2))
680             {
681                 break;
682             }
683         }
684         b = (char*)needle->string.vector.data;
685     }
686 
687     *found_index = -1;
688     return ZYAN_STATUS_FALSE;
689 }
690 
691 ZyanStatus ZyanStringRPos(const ZyanStringView* haystack, const ZyanStringView* needle,
692     ZyanISize* found_index)
693 {
694     if (!haystack)
695     {
696         return ZYAN_STATUS_INVALID_ARGUMENT;
697     }
698 
699     return ZyanStringRPosEx(haystack, needle, found_index, haystack->string.vector.size - 1,
700         haystack->string.vector.size - 1);
701 }
702 
703 ZyanStatus ZyanStringRPosEx(const ZyanStringView* haystack, const ZyanStringView* needle,
704     ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
705 {
706     if (!haystack || !needle || !found_index)
707     {
708         return ZYAN_STATUS_INVALID_ARGUMENT;
709     }
710 
711     // Don't allow access to the terminating '\0' character
712     if ((index >= haystack->string.vector.size) || (count > index))
713     {
714         return ZYAN_STATUS_OUT_OF_RANGE;
715     }
716 
717     if (!index || !count ||
718         (haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
719         (haystack->string.vector.size < needle->string.vector.size))
720     {
721         *found_index = -1;
722         return ZYAN_STATUS_FALSE;
723     }
724 
725     const char* s = (const char*)haystack->string.vector.data + index - 1;
726     const char* b = (const char*)needle->string.vector.data + needle->string.vector.size - 2;
727     for (; s >= (const char*)haystack->string.vector.data; --s)
728     {
729         if (*s != *b)
730         {
731             continue;
732         }
733         const char* a = s;
734         for (;;)
735         {
736             if (b < (const char*)needle->string.vector.data)
737             {
738                 *found_index = (ZyanISize)(a - (const char*)haystack->string.vector.data + 1);
739                 return ZYAN_STATUS_TRUE;
740             }
741             if (a < (const char*)haystack->string.vector.data + index - count)
742             {
743                 *found_index = -1;
744                 return ZYAN_STATUS_FALSE;
745             }
746             if (*a-- != *b--)
747             {
748                 break;
749             }
750         }
751         b = (char*)needle->string.vector.data + needle->string.vector.size - 2;
752     }
753 
754     *found_index = -1;
755     return ZYAN_STATUS_FALSE;
756 }
757 
758 ZyanStatus ZyanStringRPosI(const ZyanStringView* haystack, const ZyanStringView* needle,
759     ZyanISize* found_index)
760 {
761     if (!haystack)
762     {
763         return ZYAN_STATUS_INVALID_ARGUMENT;
764     }
765 
766     return ZyanStringRPosIEx(haystack, needle, found_index, haystack->string.vector.size - 1,
767         haystack->string.vector.size - 1);
768 }
769 
770 ZyanStatus ZyanStringRPosIEx(const ZyanStringView* haystack, const ZyanStringView* needle,
771     ZyanISize* found_index, ZyanUSize index, ZyanUSize count)
772 {
773     // This solution assumes that characters are represented using ASCII representation, i.e.,
774     // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
775     // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
776 
777     if (!haystack || !needle || !found_index)
778     {
779         return ZYAN_STATUS_INVALID_ARGUMENT;
780     }
781 
782     // Don't allow access to the terminating '\0' character
783     if ((index >= haystack->string.vector.size) || (count > index))
784     {
785         return ZYAN_STATUS_OUT_OF_RANGE;
786     }
787 
788     if (!index || !count ||
789         (haystack->string.vector.size == 1) || (needle->string.vector.size == 1) ||
790         (haystack->string.vector.size < needle->string.vector.size))
791     {
792         *found_index = -1;
793         return ZYAN_STATUS_FALSE;
794     }
795 
796     const char* s = (const char*)haystack->string.vector.data + index - 1;
797     const char* b = (const char*)needle->string.vector.data + needle->string.vector.size - 2;
798     for (; s >= (const char*)haystack->string.vector.data; --s)
799     {
800         if ((*s != *b) && ((*s ^ 32) != *b))
801         {
802             continue;
803         }
804         const char* a = s;
805         for (;;)
806         {
807             if (b < (const char*)needle->string.vector.data)
808             {
809                 *found_index = (ZyanISize)(a - (const char*)haystack->string.vector.data + 1);
810                 return ZYAN_STATUS_TRUE;
811             }
812             if (a < (const char*)haystack->string.vector.data + index - count)
813             {
814                 *found_index = -1;
815                 return ZYAN_STATUS_FALSE;
816             }
817             const char c1 = *a--;
818             const char c2 = *b--;
819             if ((c1 != c2) && ((c1 ^ 32) != c2))
820             {
821                 break;
822             }
823         }
824         b = (char*)needle->string.vector.data + needle->string.vector.size - 2;
825     }
826 
827     *found_index = -1;
828     return ZYAN_STATUS_FALSE;
829 }
830 
831 /* ---------------------------------------------------------------------------------------------- */
832 /* Comparing                                                                                      */
833 /* ---------------------------------------------------------------------------------------------- */
834 
835 ZyanStatus ZyanStringCompare(const ZyanStringView* s1, const ZyanStringView* s2, ZyanI32* result)
836 {
837     if (!s1 || !s2)
838     {
839         return ZYAN_STATUS_INVALID_ARGUMENT;
840     }
841 
842     if (s1->string.vector.size < s2->string.vector.size)
843     {
844         *result = -1;
845         return ZYAN_STATUS_FALSE;
846     }
847     if (s1->string.vector.size > s2->string.vector.size)
848     {
849         *result =  1;
850         return ZYAN_STATUS_FALSE;
851     }
852 
853     const char* const a = (char*)s1->string.vector.data;
854     const char* const b = (char*)s2->string.vector.data;
855     ZyanUSize i;
856     for (i = 0; (i + 1 < s1->string.vector.size) && (i + 1 < s2->string.vector.size); ++i)
857     {
858         if (a[i] == b[i])
859         {
860             continue;
861         }
862         break;
863     }
864 
865     if (a[i] == b[i])
866     {
867         *result = 0;
868         return ZYAN_STATUS_TRUE;
869     }
870 
871     if ((a[i] | 32) < (b[i] | 32))
872     {
873         *result = -1;
874         return ZYAN_STATUS_FALSE;
875     }
876 
877     *result = 1;
878     return ZYAN_STATUS_FALSE;
879 }
880 
881 ZyanStatus ZyanStringCompareI(const ZyanStringView* s1, const ZyanStringView* s2, ZyanI32* result)
882 {
883     // This solution assumes that characters are represented using ASCII representation, i.e.,
884     // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
885     // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
886 
887     if (!s1 || !s2)
888     {
889         return ZYAN_STATUS_INVALID_ARGUMENT;
890     }
891 
892     if (s1->string.vector.size < s2->string.vector.size)
893     {
894         *result = -1;
895         return ZYAN_STATUS_FALSE;
896     }
897     if (s1->string.vector.size > s2->string.vector.size)
898     {
899         *result =  1;
900         return ZYAN_STATUS_FALSE;
901     }
902 
903     const char* const a = (char*)s1->string.vector.data;
904     const char* const b = (char*)s2->string.vector.data;
905     ZyanUSize i;
906     for (i = 0; (i + 1 < s1->string.vector.size) && (i + 1 < s2->string.vector.size); ++i)
907     {
908         if ((a[i] == b[i]) || ((a[i] ^ 32) == b[i]))
909         {
910             continue;
911         }
912         break;
913     }
914 
915     if (a[i] == b[i])
916     {
917         *result = 0;
918         return ZYAN_STATUS_TRUE;
919     }
920 
921     if ((a[i] | 32) < (b[i] | 32))
922     {
923         *result = -1;
924         return ZYAN_STATUS_FALSE;
925     }
926 
927     *result = 1;
928     return ZYAN_STATUS_FALSE;
929 }
930 
931 /* ---------------------------------------------------------------------------------------------- */
932 /* Case conversion                                                                                */
933 /* ---------------------------------------------------------------------------------------------- */
934 
935 ZyanStatus ZyanStringToLowerCase(ZyanString* string)
936 {
937     if (!string)
938     {
939         return ZYAN_STATUS_INVALID_ARGUMENT;
940     }
941 
942     return ZyanStringToLowerCaseEx(string, 0, string->vector.size - 1);
943 }
944 
945 ZyanStatus ZyanStringToLowerCaseEx(ZyanString* string, ZyanUSize index, ZyanUSize count)
946 {
947     // This solution assumes that characters are represented using ASCII representation, i.e.,
948     // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
949     // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
950 
951     if (!string)
952     {
953         return ZYAN_STATUS_INVALID_ARGUMENT;
954     }
955 
956     // Don't allow access to the terminating '\0' character
957     if (index + count >= string->vector.size)
958     {
959         return ZYAN_STATUS_OUT_OF_RANGE;
960     }
961 
962     char* s = (char*)string->vector.data + index;
963     for (ZyanUSize i = index; i < index + count; ++i)
964     {
965         const char c = *s;
966         if ((c >= 'A') && (c <= 'Z'))
967         {
968             *s = c | 32;
969         }
970         ++s;
971     }
972 
973     return ZYAN_STATUS_SUCCESS;
974 }
975 
976 ZyanStatus ZyanStringToUpperCase(ZyanString* string)
977 {
978     if (!string)
979     {
980         return ZYAN_STATUS_INVALID_ARGUMENT;
981     }
982 
983     return ZyanStringToUpperCaseEx(string, 0, string->vector.size - 1);
984 }
985 
986 ZyanStatus ZyanStringToUpperCaseEx(ZyanString* string, ZyanUSize index, ZyanUSize count)
987 {
988     // This solution assumes that characters are represented using ASCII representation, i.e.,
989     // codes for 'a', 'b', 'c', .. 'z' are 97, 98, 99, .. 122 respectively. And codes for 'A',
990     // 'B', 'C', .. 'Z' are 65, 66, .. 95 respectively.
991 
992     if (!string)
993     {
994         return ZYAN_STATUS_INVALID_ARGUMENT;
995     }
996 
997     // Don't allow access to the terminating '\0' character
998     if (index + count >= string->vector.size)
999     {
1000         return ZYAN_STATUS_OUT_OF_RANGE;
1001     }
1002 
1003     char* s = (char*)string->vector.data + index;
1004     for (ZyanUSize i = index; i < index + count; ++i)
1005     {
1006         const char c = *s;
1007         if ((c >= 'a') && (c <= 'z'))
1008         {
1009             *s = c & ~32;
1010         }
1011         ++s;
1012     }
1013 
1014     return ZYAN_STATUS_SUCCESS;
1015 }
1016 
1017 /* ---------------------------------------------------------------------------------------------- */
1018 /* Memory management                                                                              */
1019 /* ---------------------------------------------------------------------------------------------- */
1020 
1021 ZyanStatus ZyanStringResize(ZyanString* string, ZyanUSize size)
1022 {
1023     if (!string)
1024     {
1025         return ZYAN_STATUS_INVALID_ARGUMENT;
1026     }
1027 
1028     ZYAN_CHECK(ZyanVectorResize(&string->vector, size + 1));
1029     ZYCORE_STRING_NULLTERMINATE(string);
1030 
1031     return ZYAN_STATUS_SUCCESS;
1032 }
1033 
1034 ZyanStatus ZyanStringReserve(ZyanString* string, ZyanUSize capacity)
1035 {
1036     if (!string)
1037     {
1038         return ZYAN_STATUS_INVALID_ARGUMENT;
1039     }
1040 
1041     return ZyanVectorReserve(&string->vector, capacity);
1042 }
1043 
1044 ZyanStatus ZyanStringShrinkToFit(ZyanString* string)
1045 {
1046     if (!string)
1047     {
1048         return ZYAN_STATUS_INVALID_ARGUMENT;
1049     }
1050 
1051     return ZyanVectorShrinkToFit(&string->vector);
1052 }
1053 
1054 /* ---------------------------------------------------------------------------------------------- */
1055 /* Information                                                                                    */
1056 /* ---------------------------------------------------------------------------------------------- */
1057 
1058 ZyanStatus ZyanStringGetCapacity(const ZyanString* string, ZyanUSize* capacity)
1059 {
1060     if (!string)
1061     {
1062         return ZYAN_STATUS_INVALID_ARGUMENT;
1063     }
1064 
1065     ZYAN_ASSERT(string->vector.capacity >= 1);
1066     *capacity = string->vector.capacity - 1;
1067 
1068     return ZYAN_STATUS_SUCCESS;
1069 }
1070 
1071 ZyanStatus ZyanStringGetSize(const ZyanString* string, ZyanUSize* size)
1072 {
1073     if (!string)
1074     {
1075         return ZYAN_STATUS_INVALID_ARGUMENT;
1076     }
1077 
1078     ZYAN_ASSERT(string->vector.size >= 1);
1079     *size = string->vector.size - 1;
1080 
1081     return ZYAN_STATUS_SUCCESS;
1082 }
1083 
1084 ZyanStatus ZyanStringGetData(const ZyanString* string, const char** value)
1085 {
1086     if (!string)
1087     {
1088         return ZYAN_STATUS_INVALID_ARGUMENT;
1089     }
1090 
1091     *value = string->vector.data;
1092 
1093     return ZYAN_STATUS_SUCCESS;
1094 }
1095 
1096 /* ---------------------------------------------------------------------------------------------- */
1097 
1098 /* ============================================================================================== */
1099