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

1100